Jason Notes

Ubuntu 系統設定與開發環境配置指南

目錄

• 系統套件管理
• 系統基本設定
• 開發工具安裝
• 開發環境配置
• 中文輸入法設定
• 系統效能優化
• 工具軟體安裝

系統套件管理

選擇套件來源

sudo /usr/bin/software-properties-gtk

Ubuntu 22.04 套件安裝

sudo apt-get install autoconf automake linux-headers-`uname -r` \
 libclang-dev p7zip guake p7zip-full liblzma-dev \
 indicator-multiload filezilla pidgin pcmanx-gtk2 gparted meld \
 speedcrunch vim ssh id-utils cflow autogen \
 cutecom hexedit ccache clang pbzip2 smplayer plink putty-tools \
 ghex doxygen doxygen-doc libstdc++6 lib32stdc++6 build-essential \
 doxygen-gui graphviz git-core cconv alsa-oss wmctrl terminator \
 curl cgdb dos2unix libreadline-dev tmux \
 hexedit ccache ruby subversion htop astyle ubuntu-restricted-extras \
 libncurses5-dev xdot universal-ctags cscope \
 libsdl1.2-dev gitk libncurses5-dev binutils-dev gtkterm \
 libtool mpi-default-dev libbz2-dev libicu-dev scons csh \
 enca ttf-anonymous-pro libperl4-corelibs-perl cgvg catfish gawk \
 i2c-tools sshfs wavesurfer audacity fcitx fcitx-chewing libswitch-perl bin86 \
 inotify-tools u-boot-tools subversion crash tree mscgen krename umbrello \
 intel2gas kernelshark trace-cmd pppoe dcfldd flex bison help2man \
 texinfo texi2html ghp-import autossh samba sdcv xournal cloc geogebra \
 libluajit-5.1-dev libacl1-dev libgpmg1-dev libgtk-3-dev libgtk2.0-dev \
 liblua5.2-dev libperl-dev libselinux1-dev libtinfo-dev libxaw7-dev \
 libxpm-dev libxt-dev gnome-control-center gettext libtool libtool-bin cmake g++ pkg-config unzip xsel

Ubuntu 24.04 套件安裝

sudo apt-get install autoconf automake linux-headers-`uname -r` \
clang xdot git meld gparted cmake g++ pkg-config unzip xsel librust-openssl-dev \
terminator universal-ctags cscope htop libfuse2 ghp-import libpcre3-dev libpcre2-dev curl fonts-firacode

常見問題修正

Balena Etcher 在 Ubuntu 24.04 的修正

sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0

系統基本設定

網路連線修復

解決有線連線不見或網路圖示消失的問題：

sudo apt-get install gnome-control-center
sudo service network-manager stop
sudo rm /var/lib/NetworkManager/NetworkManager.state
sudo service network-manager start
sudo gedit /etc/NetworkManager/NetworkManager.conf
# 把 managed=false 改成 managed=true
sudo service network-manager restart

檔案開啟工具設定

sudo ln -s /usr/bin/xdg-open ~/.mybin/o

時區設定

# 互動式時區設定
tzselect

# 設定台北時區
sudo cp /usr/share/zoneinfo/Asia/Taipei /etc/localtime

# 安裝時間同步工具
sudo apt-get install ntpdate

# 同步時間
sudo ntpdate time.stdtime.gov.tw
sudo hwclock -w

# 設定自動時間同步
echo "@daily /usr/sbin/ntpdate time.stdtime.gov.tw > /dev/null" | crontab -

開發工具安裝

常用開發工具 Git Repositories

git clone https://github.com/clvv/fasd
git clone https://github.com/junegunn/fzf
git clone https://github.com/sharkdp/fd
git clone https://github.com/cgdb/cgdb
git clone https://github.com/neovim/neovim.git
git clone https://github.com/BurntSushi/ripgrep
git clone https://github.com/ggreer/the_silver_searcher
git clone https://github.com/universal-ctags/ctags

CMake 編譯工具安裝

wget https://cmake.org/files/v3.26/cmake-3.26.0.tar.gz
./bootstrap --prefix=$HOME/.mybin/cmake
make 
make install
export PATH="$HOME/.mybin/cmake/bin:$PATH"

開發環境配置

Node.js 安裝

# 下載地址：https://nodejs.org/en/
export N_PREFIX=$HOME/.mybin/node-v17.8.0-linux-x64/
export PATH=$N_PREFIX/bin:$PATH

GitBook 安裝

sudo apt-get update
sudo apt-get install nodejs npm
sudo npm install gitbook -g

Rust 程式語言安裝

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env

# 更新 Rust 版本
rustup update

GitHub 多帳號 SSH 設定

cd ~/.ssh
ssh-keygen -t rsa -C "account1@email.com" -f id_rsa_account1
ssh-keygen -t rsa -C "account2@email.com" -f id_rsa_account2

# 建立 config 檔
touch config

# 編輯 config 檔內容
cat << EOF > config
#account1
Host github.com-account1
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_rsa_account1

#account2
Host github.com-account2
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_rsa_account2
EOF

# 修改相對應 repo 的 remote url 範例：
# ssh://git@github.com-account1/username/repo1.git

中文輸入法設定

Ubuntu 22.04 以前版本 (fcitx)

sudo apt-get install fcitx-table-boshiamy     # 嘸蝦米
sudo apt-get install fcitx-table-cangjie-big  # 倉頡大字集
sudo apt-get install fcitx-table-zhengma-large # 鄭碼大字集
sudo apt-get install fcitx-table-wubi-large   # 五筆大字集
sudo apt-get install fcitx-chewing            # 新酷音
sudo apt-get install fcitx-sunpinyin          # 雙拼
sudo apt-get install fcitx-table-easy-big     # 輕鬆大詞庫
sudo apt-get install fcitx-m17n
sudo apt-get remove ibus

# 設定輸入法
im-config
# 選 fcitx 為預設，重開機或重新登入
# 切換快捷鍵：Ctrl+Space (切換輸入法), Ctrl+Shift (選擇輸入法), Ctrl+Shift+F (簡繁轉換)

Ubuntu 24.04 版本 (fcitx5)

# 更新套件列表
sudo apt update

# 安裝 fcitx5 核心組件
sudo apt install fcitx5 fcitx5-chinese-addons fcitx5-frontend-gtk4 fcitx5-frontend-gtk3 fcitx5-frontend-qt5

# 安裝庫注音輸入法
sudo apt install fcitx5-chewing

# 安裝 fcitx5 設定工具
sudo apt install fcitx5-config-qt fcitx5-data

設定環境變數

# 編輯 ~/.bashrc
cat << 'EOF' >> ~/.bashrc
export GTK_IM_MODULE=fcitx
export QT_IM_MODULE=fcitx
export XMODIFIERS=@im=fcitx
export INPUT_METHOD=fcitx
export SDL_IM_MODULE=fcitx
export GLFW_IM_MODULE=ibus
EOF

設定自動啟動

cp /usr/share/applications/org.fcitx.Fcitx5.desktop ~/.config/autostart/

設定輸入法

1. 開啟 fcitx5 設定工具：在應用程式選單中找到「Fcitx 5 Configuration」
2. 點擊左下角的「+」號新增輸入法
3. 取消勾選「Only Show Current Language」
4. 搜尋「Chewing」並加入
5. 可以調整輸入法的順序

故障排除

# 診斷設定
fcitx5-diagnose

系統效能優化

虛擬記憶體 (Swap) 設定

# 1. 建立 4GB swap 檔案
sudo fallocate -l 4G /swapfile

# 2. 設定權限並啟用
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

# 3. 設定開機自動掛載
echo '/swapfile   none swap    sw 0 0' | sudo tee -a /etc/fstab

RamDisk 設定

將 /tmp 目錄設置到記憶體中以提升效能：

# 建立臨時目錄
mkdir /dev/shm/tmp
chmod 1777 /dev/shm/tmp
sudo mount --bind /dev/shm/tmp /tmp

開機自動執行設定

# 建立啟動腳本
sudo tee /etc/init.d/ramtmp.sh << 'EOF'
#!/bin/sh
# RamDisk tmp
PATH=/sbin:/bin:/usr/bin:/usr/sbin

mkdir -p /dev/shm/tmp
mkdir -p /dev/shm/cache
mount --bind /dev/shm/tmp /tmp
mount --bind /dev/shm/cache /home/shihyu/.cache
chmod 1777 /dev/shm/tmp
chmod 1777 /dev/shm/cache
EOF

# 設定執行權限
sudo chmod 755 /etc/init.d/ramtmp.sh

# 建立開機啟動連結
cd /etc/rcS.d
sudo ln -s ../init.d/ramtmp.sh S50ramtmp.sh

工具軟體安裝

電子書閱讀器 Foliate

支援 .epub、.mobi、.azw 和 .azw3 格式（不支援 PDF）：

sudo add-apt-repository ppa:apandada1/foliate
sudo apt update
sudo apt install foliate

AdGuard VPN CLI 安裝

# 安裝 AdGuard VPN CLI
curl -fsSL https://raw.githubusercontent.com/AdguardTeam/AdGuardVPNCLI/master/scripts/release/install.sh | sh -s -- -v

# 登入帳號
adguardvpn-cli login

# 連線 VPN
adguardvpn-cli connect

# 查看可用位置
adguardvpn-cli list-locations

# 連線到指定位置
adguardvpn-cli connect -l Tokyo

# 其他常用指令
adguardvpn-cli logout           # 登出
adguardvpn-cli check-update     # 檢查更新
adguardvpn-cli --help-all       # 查看所有指令
adguardvpn-cli uninstall        # 移除

常用指令

檔案管理

查找大檔案

find . -type f -size +10M  ! -name '*.cpp' ! -name '*.c' ! -name '*.rs' ! -name '*.java'

清理非代碼檔案

find . -not -path '*/\.git/*' -not -path '*readme*' -type f    ! -name '*.cpp' ! -name '*.c' ! -name '*.rs' ! -name '*.java' ! -name '*.go' ! -name '*.cc' ! -name '*.h' ! -name '*.kt' ! -name '*.py'  ! -name '*.sh'  ! -name '*.asm' ! -name '*.pl' ! -name '*.sed'  ! -name '*.hpp'  ! -name '*.cxx' ! -name '*makefile*'  ! -name '*.json' -exec rm {} \;

查找超過 1MB 的檔案

find . -type f -not -path '*/\.git/*' -size +1M

檔案傳輸工具

Transfer.sh

使用 transfer.sh 快速分享檔案

安裝 transfer 函數

transfer(){ 
    if [ $# -eq 0 ];then 
        echo "No arguments specified.\nUsage:\n transfer <file|directory>\n ... | transfer <file_name>">&2
        return 1
    fi
    if tty -s;then 
        file="$1"
        file_name=$(basename "$file")
        if [ ! -e "$file" ];then 
            echo "$file: No such file or directory">&2
            return 1
        fi
        if [ -d "$file" ];then 
            file_name="$file_name.zip"
            (cd "$file"&&zip -r -q - .)|curl --progress-bar --upload-file "-" "https://transfer.sh/$file_name"|tee /dev/null
        else 
            cat "$file"|curl --progress-bar --upload-file "-" "https://transfer.sh/$file_name"|tee /dev/null
        fi
    else 
        file_name=$1
        curl --progress-bar --upload-file "-" "https://transfer.sh/$file_name"|tee /dev/null
    fi
}

使用範例

# 使用 cURL 直接上傳
curl --upload-file ./hello.txt https://transfer.sh/hello.txt

# 使用 transfer 函數
transfer hello.txt
# 輸出: ##################################################### 100.0% https://transfer.sh/zmlFh3/hello.txt

# 網頁上傳
# 將檔案拖拽到 transfer.sh 網站或點擊選擇檔案

以下是將 ccusage CLI 工具的使用說明整理成 Markdown 格式的內容，方便閱讀或加入到文件中：

ccusage 使用說明

安裝

npm install -g ccusage

📊 基本用法

📺 即時監控

ccusage blocks --live

顯示即時的使用儀表板。

🧰 過濾與選項

範例：

ccusage daily --since 20250525 --until 20250530
ccusage daily --json
ccusage daily --breakdown

📁 專案分析

範例：

ccusage daily --instances
ccusage daily --project myproject
ccusage daily --instances --project myproject --json

需要我幫你加入範例畫面或轉成 GitHub README 模板嗎？

使用 Docker 編譯 GitBook 說明

使用下列指令，可以在 Docker 環境中編譯 GitBook 專案，不需在本機安裝 GitBook：

docker run --rm -v "$PWD":/book -w /book fellah/gitbook gitbook build


| 參數                | 說明                                                   |
| ----------------- | ---------------------------------------------------- |
| `docker run`      | 使用 Docker 執行一個容器                                     |
| `--rm`            | 執行完後自動移除容器，保持環境乾淨                                    |
| `-v "$PWD":/book` | 將當前目錄（`$PWD`）掛載到容器的 `/book` 目錄，讓容器能存取你的 GitBook 專案檔案 |
| `-w /book`        | 設定容器內的工作目錄為 `/book`（也就是你專案的根目錄）                      |
| `fellah/gitbook`  | 使用的 Docker 映像，內含 GitBook 編譯工具                        |
| `gitbook build`   | GitBook 的編譯指令，會將 Markdown 轉換成靜態 HTML，輸出到 `_book` 目錄中 |

GCP SSH 連線設定指南

完整的 Google Cloud Platform 虛擬機器 SSH 連線設定步驟：

1. 生成 SSH 金鑰

# 替換 your.email@gmail.com 為你的 Gmail
ssh-keygen -t rsa -b 2048 -C "your.email@gmail.com" -f ~/.ssh/myssh/gcp_new

gcp 帳號 chhi3758
ssh-keygen -t rsa -b 2048 -C "chhi3758" -f ~/.ssh/myssh/gcp_chhi3758

2. 設定 SSH 公鑰

# 查看公鑰
cat ~/.ssh/myssh/gcp_new.pub

# 格式應該要像：
ssh-rsa AAAAB3Nza... autoicash2023
# 注意：最後的使用者名稱要改成你的 GCP 登入帳號

3. GCP 主控台設定

• 前往：Compute Engine > 中繼資料 > SSH 金鑰
• 點選「編輯」
• 貼上修改後的公鑰

4. SSH 金鑰權限設定

chmod 600 ~/.ssh/myssh/gcp_new
ssh-add ~/.ssh/myssh/gcp_new

5. SSH 連線測試

ssh -i ~/.ssh/myssh/gcp_new autoicash2023@35.185.159.162

6. 系統設定

語系設定

# 安裝語言包
sudo apt-get update
sudo apt-get install -y language-pack-zh-hant language-pack-zh-hans

# 設定 locales
sudo locale-gen zh_TW.UTF-8
sudo update-locale LANG=zh_TW.UTF-8 LC_ALL=zh_TW.UTF-8

# 編輯設定檔
sudo bash -c 'cat > /etc/default/locale << EOF
LANG=zh_TW.UTF-8
LANGUAGE=zh_TW:zh
LC_ALL=zh_TW.UTF-8
EOF'

時區設定

# 安裝需要的套件
sudo apt-get install -y util-linux ntpdate

# 設定台北時區
sudo timedatectl set-timezone Asia/Taipei
# 或
sudo ln -sf /usr/share/zoneinfo/Asia/Taipei /etc/localtime

# 更新時間
sudo ntpdate time.stdtime.gov.tw

# 確認設定
date
timedatectl

7. 完成設定

exit
# 然後重新 SSH 連線

重要提醒

• 確保公鑰內的使用者名稱與 SSH 連線時使用的相同
• 每個指令執行後最好確認是否成功
• 如果遇到問題，可以查看系統日誌：sudo tail -f /var/log/syslog

Wine 編譯與安裝指南

1. 下載 Wine 原始碼

git clone https://github.com/wine-mirror/wine

# 如果只是使用wine，就選擇下載不帶git的wine原始碼。
wget https://github.com/wine-mirror/wine/archive/refs/heads/master.zip && unzip master.zip && mv wine-master wine

# 如果要回溯wine或者維護補丁，就選擇下載帶git的wine原始碼。
# git clone git://source.winehq.org/git/wine.git ~/wine

2. 安裝編譯依賴

手動安裝編譯依賴、64 位運行依賴和 32 位運行依賴：

sudo apt install gcc-multilib g++-multilib flex bison gcc make gcc-mingw-w64 libasound2-dev libpulse-dev libdbus-1-dev libfontconfig1-dev libfreetype6-dev libgnutls28-dev  libpng-dev libtiff-dev libunwind-dev libx11-dev libxml2-dev libxslt1-dev libfaudio-dev libgstreamer1.0-dev libmpg123-dev libosmesa6-dev libudev-dev libvkd3d-dev libvulkan-dev libcapi20-dev liblcms2-dev libcups2-dev libgphoto2-dev libsane-dev libgsm1-dev libkrb5-dev libldap2-dev ocl-icd-opencl-dev libpcap-dev libusb-1.0-0-dev libv4l-dev libopenal-dev  libasound2-dev:i386 libpulse-dev:i386 libdbus-1-dev:i386 libfontconfig1-dev:i386 libfreetype6-dev:i386 libgnutls28-dev:i386 libpng-dev:i386 libtiff-dev:i386 libunwind-dev:i386 libx11-dev:i386 libxml2-dev:i386 libxslt1-dev:i386 libfaudio-dev:i386 libgstreamer1.0-dev:i386 libgstreamer-plugins-base1.0-dev:i386 libmpg123-dev:i386 libosmesa6-dev:i386 libsdl2-dev:i386 libudev-dev:i386 libvkd3d-dev:i386 libvulkan-dev:i386 libcapi20-dev:i386 liblcms2-dev:i386 libcups2-dev:i386 libgphoto2-dev:i386 libsane-dev:i386 libgsm1-dev:i386 libkrb5-dev:i386 libldap2-dev:i386 ocl-icd-opencl-dev:i386 libpcap-dev:i386 libusb-1.0-0-dev:i386 libv4l-dev:i386 libopenal-dev:i386 libjpeg-turbo8-dev libjpeg-turbo8-dev:i386 libxcomposite-dev libxcomposite-dev:i386 libc6-i386

3. Wine 編譯與安裝

### 安裝到系統目錄（日常使用）
bash
# 編譯並安裝到系統目錄
cd wine 
./configure --disable-tests 
make -j$(nproc) 
sudo make install

# 使用wine運行內建應用notepad。
wine notepad

### 安裝到指定目錄（測試用）
# 編譯並安裝到指定目錄
mkdir build release 
cd build 
../wine/configure --disable-tests  
make -j$(nproc) 
make install DESTDIR=../release

# 使用wine運行內建應用notepad。
../release/usr/local/bin/wine notepad

4. 64 位 Wine 編譯

# 假設wine原始碼在src目錄中，然後在src同級建立開始執行
mkdir src win32 win64 release

cd win64
../src/configure --disable-tests --enable-win64
make -j$(nproc)
make install DESTDIR=../release

cd ../win32
../src/configure --disable-tests --with-wine64=../win64
make -j$(nproc)
make install DESTDIR=../release

5. 離線依賴包製作

當套件來源會影響依賴安裝時，可以製作離線依賴包用於編譯或運行。在純淨環境中執行以下步驟：

sudo apt clean

sudo apt install gcc-multilib g++-multilib  gcc make gcc-mingw-w64 \
flex bison libasound2-dev libpulse-dev libdbus-1-dev libfontconfig1-dev libfreetype6-dev libgnutls28-dev  libpng-dev libtiff-dev libunwind-dev libx11-dev libxml2-dev libxslt1-dev libfaudio-dev libgstreamer1.0-dev libmpg123-dev libosmesa6-dev libudev-dev libvkd3d-dev libvulkan-dev libcapi20-dev liblcms2-dev libcups2-dev libgphoto2-dev libsane-dev libgsm1-dev libkrb5-dev libldap2-dev ocl-icd-opencl-dev libpcap-dev libusb-1.0-0-dev libv4l-dev libopenal-dev  libasound2-dev:i386 libpulse-dev:i386 libdbus-1-dev:i386 libfontconfig1-dev:i386 libfreetype6-dev:i386 libgnutls28-dev:i386 libpng-dev:i386 libtiff-dev:i386 libunwind-dev:i386 libx11-dev:i386 libxml2-dev:i386 libxslt1-dev:i386 libfaudio-dev:i386 libgstreamer1.0-dev:i386 libgstreamer-plugins-base1.0-dev:i386 libmpg123-dev:i386 libosmesa6-dev:i386 libsdl2-dev:i386 libudev-dev:i386 libvkd3d-dev:i386 libvulkan-dev:i386 libcapi20-dev:i386 liblcms2-dev:i386 libcups2-dev:i386 libgphoto2-dev:i386 libsane-dev:i386 libgsm1-dev:i386 libkrb5-dev:i386 libldap2-dev:i386 ocl-icd-opencl-dev:i386 libpcap-dev:i386 libusb-1.0-0-dev:i386 libv4l-dev:i386 libopenal-dev:i386 libjpeg-turbo8-dev libjpeg-turbo8-dev:i386 libxcomposite-dev libxcomposite-dev:i386 libc6-i386

cp -r /var/cache/apt/archives ~
cd archives; rm -rf partial
mkdir ../wine-depends
x=$(ls);for y in $x;do dpkg-deb -x $y ../wine-depends;done

### 用法說明
為了不影響系統環境，可使用環境變數設定庫的搜尋路徑：

```sh
export LD_LIBRARY_PATH=<離線依賴路徑>:$LD_LIBRARY_PATH

安裝圖形界面管理工具（如果還沒裝的話）

sudo apt install blueman# Ubuntu 藍牙設備設定指南

安裝必要套件

# 更新系統套件
sudo apt update && sudo apt upgrade

# 安裝基本藍牙支援
sudo apt install bluetooth bluez bluez-tools blueman

# 安裝除錯工具
sudo apt install bluez-hcidump

# 安裝藍牙開發庫
sudo apt install libbluetooth-dev

啟動藍牙服務

# 啟動並啟用藍牙服務
sudo systemctl enable bluetooth
sudo systemctl start bluetooth

# 檢查服務狀態
sudo systemctl status bluetooth

設定用戶權限

# 確保用戶在藍牙群組中
sudo usermod -a -G bluetooth $USER

# 檢查群組設定
groups $USER

基本操作指令

# 檢查藍牙適配器
bluetoothctl list
hciconfig

# 檢查已配對設備
bluetoothctl devices

# 進入藍牙控制模式
bluetoothctl
# 在 bluetoothctl 中可用指令：
# show - 顯示適配器信息
# devices - 列出設備
# info [MAC地址] - 查看設備詳細信息
# connect [MAC地址] - 連接設備
# disconnect [MAC地址] - 斷開設備

Chrome 藍牙功能設定

啟用 Chrome 藍牙 API

1. 在 Chrome 位址欄輸入：

   chrome://flags
   

2. 搜尋並啟用以下功能：

   • #enable-web-bluetooth - 啟用 Web Bluetooth API
   • #enable-experimental-web-platform-features - 啟用實驗性網頁平台功能
   • #bluetooth-web-api - 啟用藍牙網頁 API

3. 重新啟動 Chrome 瀏覽器

Chrome 開啟方法

方法一：終端機啟動

# 直接啟動 Chrome
google-chrome

# 或者使用 chromium
chromium-browser

# 在背景執行
google-chrome &

方法二：桌面環境

• 點擊應用程式選單
• 搜尋 "Chrome" 或 "Chromium"
• 點擊圖示開啟

方法三：快捷鍵（如果有設定）

• Super + Space（搜尋應用程式）
• 輸入 "chrome" 後按 Enter

疑難排解

如果藍牙設備連接有問題：

# 重新啟動藍牙服務
sudo systemctl restart bluetooth

# 重新載入藍牙模組
sudo modprobe -r bluetooth
sudo modprobe bluetooth
sudo modprobe btusb

# 檢查藍牙硬體
lsusb | grep -i bluetooth
hciconfig -a

注意事項

• 重新登入系統以確保群組權限生效
• 某些特殊功能設備可能需要額外的驅動程式
• 公司網路環境可能有安全限制，需要管理員權限設定
• 定期更新系統以獲得最新的藍牙驅動支援

Hello Docker

• Dockerfile

FROM python:3.7-slim

# Add requirements file in the container
COPY requirements.txt ./requirements.txt
RUN pip install -r requirements.txt

# Add source code in the container
COPY main.py ./main.py

# Define container entry point (could also work with CMD python main.py)
ENTRYPOINT ["python", "main.py"]

• requirements.txt

requests==2.27.1

• main.py

from pip import _internal

if __name__ == '__main__':
    print('Hello Docker world!')
    _internal.main(['list'])

docker build -t docker-python-helloworld .
docker images 
# docker create -i -t --name 光碟機  iso
docker create -i -t --name  docker_test docker-python-helloworld
docker ps
docker start -i docker_test
docker stop docker_test

Docker & Docker Compose 安裝與配置

Docker 安裝

Ubuntu/Debian 系統安裝 Docker

# 更新系統套件
sudo apt update

# 安裝 Docker
sudo apt install docker.io

# 創建 docker 用戶組（如果不存在）
sudo groupadd docker

# 將當前用戶加入 docker 組
sudo usermod -aG docker ${USER}

# 設置 Docker socket 權限
sudo chmod 666 /var/run/docker.sock

# 重啟 Docker 服務
sudo systemctl enable docker
sudo systemctl start docker

# 需要退出重新登錄後才會生效

驗證 Docker 安裝

docker --version
docker run hello-world

Docker Compose 安裝

方法 1: 使用 apt 安裝（推薦）

# Ubuntu 20.04+ 可直接使用 apt 安裝最新版本
sudo apt update
sudo apt install docker-compose-plugin

# 驗證安裝
docker compose version

方法 2: 手動安裝最新版本

# 下載最新版本的 Docker Compose
# 請先檢查最新版本：https://github.com/docker/compose/releases/
COMPOSE_VERSION="v2.24.0"
sudo curl -L "https://github.com/docker/compose/releases/download/${COMPOSE_VERSION}/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# 設置可執行權限
sudo chmod +x /usr/local/bin/docker-compose

# 創建符號連結（可選）
sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

# 驗證安裝
docker-compose --version

方法 3: 使用 pip 安裝

# 使用 Python pip 安裝
pip3 install docker-compose

# 或者使用虛擬環境安裝
python3 -m venv docker-env
source docker-env/bin/activate
pip install docker-compose

Docker Compose 基本使用

Docker Compose 簡介

Docker Compose 是用於定義和執行多容器 Docker 應用程式的工具。使用 YAML 檔案來配置應用程式的服務，然後使用一個命令就可以創建並啟動所有服務。

Docker Compose 基本命令

docker-compose.yml 範例

基本的 Web 應用程式 + 資料庫

version: '3.8'

services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - db
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/mydb
    volumes:
      - .:/app
    
  db:
    image: postgres:15
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

volumes:
  postgres_data:

WordPress + MySQL 範例

version: '3.8'

services:
  wordpress:
    image: wordpress:latest
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: mysql:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: password
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - wordpress_data:/var/www/html
    depends_on:
      - mysql

  mysql:
    image: mysql:8.0
    environment:
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: password
      MYSQL_ROOT_PASSWORD: rootpassword
    volumes:
      - mysql_data:/var/lib/mysql

volumes:
  wordpress_data:
  mysql_data:

Docker Compose 常用選項

服務配置選項

• build: 建置 Docker 映像檔的路徑或配置
• image: 使用的 Docker 映像檔
• ports: 連接埠映射
• volumes: 資料卷掛載
• environment: 環境變數
• depends_on: 服務依賴關係
• networks: 網路配置
• restart: 重啟策略

執行選項

# 背景執行
docker compose up -d

# 重新建置並啟動
docker compose up --build

# 指定檔案
docker compose -f docker-compose.prod.yml up

# 擴展服務實例
docker compose up --scale web=3

# 停止並移除所有容器、網路
docker compose down

# 停止並移除所有容器、網路、映像檔、卷
docker compose down --rmi all --volumes

Docker 教學

docker實際上,就是一個系統聯合幾個元件一直在欺騙一個處理程序,主要依靠了三個幫凶namespace,chroot,cgroup

Containers as a Service ( CaaS ) - 容器如同服務 Docker 是一個開源專案，出現於 2013 年初，最初是 Dotcloud 公司內部的 Side-Project。 它基於 Google 公司推出的 Go 語言實作。（ Dotcloud 公司後來改名為 Docker ）

Agenda

• 基本介紹 - 映像檔、容器、倉庫
• 指令說明 - 安裝、指令
• Dockerfile 說明
• 進階應用 - docker compose
• 進階應用 - docker machine
• 實際案例

基本介紹

什麼是容器技術Container： 應用程式為中心的虛擬化

Docker 歷史

1982年Unix系統內建的chroot機制 LXC 利用controler groups 與namespaces的功能， 提供應用軟體一個獨立的作業系統環境 2013 Linux之父Linus Torvalds 發布Linux核心3.8版 支援Container技術 2013 dotCloud公司將內部專案Docker開源釋出程式碼

Containers(容器) vs Virtual Machines(虛擬主機)

Docker 三個基本概念

映像檔（Image）

• Docker 映像檔就是一個唯讀的模板。
• 映像檔可以用來建立 Docker 容器。

容器（Container）

• 容器是從映像檔建立的執行實例。
• Docker 利用容器來執行應用。
• 可以被啟動、開始、停止、刪除。
• 每個容器都是相互隔離的、保證安全的平臺。

倉庫（Repository）

• 倉庫是集中存放映像檔檔案的場所。
• 每個倉庫中又包含了多個映像檔。
• 每個映像檔有不同的標籤（tag）。
• 倉庫分為公開倉庫（Public）和私有倉庫（Private）兩種形式。

指令說明 - 安裝、指令

docker --help

安裝Docker

官方文件 Get started with Docker for Mac 官方官方 Get started with Docker for Windows Docker Toolbox overview

Image 映像檔 常用指令

Search 搜尋 CentOS 映像檔

docker search centos

NAME：映像檔名稱 DESCRIPTION：映像檔描述 STARS：越多代表越多人使用 OFFICIAL：官方Image AUTOMATED：自動化

顯示目前本機的 Images 列表

docker images

REPOSITORY：倉庫位置和映像檔名稱 TAG：映像檔標籤(通常是定義版本號) IMAGE ID：映像檔ID(唯一碼) CREATED：創建日期 SIZE：映像檔大小

啟動容器

docker run -ti centos /bin/bash

run : 參數說明 or docker run --help 常用： -i ：則讓容器的標準輸入保持打開 -t：讓Docker分配一個虛擬終端（pseudo-tty）並綁定到容器的標準輸入上 -d：背景執行 -e：設定環境變數(AAA=BBB) -p：Port 對應(host port:container port) -v：資料對應(host folder:container folder) --name：設定容器名稱

** 在執行RUN 映像檔時，如果沒有下載會先下載在執行 **

rmi : 刪除映像檔前要先移除所有Container build : 使用build 指令時要先切換到Dockerfile 目錄下面

Container 容器 常用指令

啟動一個 Container 並且執行 ping google.com

docker run centos ping google.com

請動一個 Container 執行上面的動作，並背景執行

使用 查看 Container 指令

docker ps 
docker ps -a

ps : 參數說明 or docker ps --help 常用： -a：顯示全部的容器

CONTAINER ID：容器ID IMAGE：映像檔名稱 COMMAND：執行指令 CREATED：創建時間 STATUS：容器狀態 POSTS：開啟的Port號 NAMES：容器名稱

顯示容器的 log

docker logs -f 8a

logs : 參數說明 or docker logs --help 常用： -f：不會跳出，會一直列印最新的log資訊

進入容器

docker exec -ti 8a /bin/bash

exec : 參數說明 or docker exec --help 常用： -i ：則讓容器的標準輸入保持打開 -t：讓Docker分配一個虛擬終端（pseudo-tty）並綁定到容器的標準輸入上 -e：設定環境變數(AAA=BBB)

查看容器資訊

docker inspect 8a

開啟容器到關閉容器

docker run -d ubuntu:14.04 /bin/sh -c "while true; do echo hello world; sleep 1; done"
db0e9dbb150596a3a89db056d0ecb765c54c3c2fb5d428e3b35fc20b55813862
docker logs -f db
docker ps -a
docker stop db
docker ps -a

Registry 倉庫 常用指令

對容器存檔

docker run -d ubuntu:14.04 /bin/sh -c "while true; do echo hello world; sleep 1; done"
96ea2a3f99e92ddd5fa0ec29f21d035703b6512f59c4f54fbaee551ee8fc044a
docker commit 96 aaa:v1

對映像檔打標籤

docker tag centos aaa asia.gcr.io/joyi-205504/aaa:v1

上傳到 GCP Registry

gcloud docker -- push  asia.gcr.io/joyi-205504/aaa:v1

其他常用指令

刪除

docker rmi `docker images|grep sele |awk '{print $3}'`

Dcoker 資料管理

資料卷（Data volumes）

• 資料卷可以在容器之間共享和重用
• 對資料卷的修改會立馬生效
• 對資料卷的更新，不會影響映像檔
• 卷會一直存在，直到沒有容器使用

範例：建立一個 web 容器，並載入一個資料捲到容器的 /webapp 目錄

docker run -d -P --name web -v /webapp training/webapp python app.py

範例：本機的 /src/webapp 目錄到容器的 /opt/webapp 目錄

docker run -d -P --name web -v /src/webapp:/opt/webapp training/webapp python app.py

範例：Docker 掛載資料卷的預設權限是讀寫，使用者也可以透過 :ro 指定為唯讀

docker run -d -P --name web -v /src/webapp:/opt/webapp:ro training/webapp python app.py

資料卷容器（Data volume containers）

持續更新的資料需要在容器之間共享，最好建立資料卷容器。 一個正常的容器，專門用來提供資料卷供其它容器掛載的。

範例：建立一個命名的資料卷容器 dbdata

docker run -d -v /dbdata --name dbdata postgres echo Data-only container for postgres

範例：他容器中使用 --volumes-from 來掛載 dbdata 容器中的資料卷

docker run -d -P --volumes-from dbdata --name db1 postgres
docker run -d -P --volumes-from dbdata --name db2 postgres

範例：也可以從其他已經掛載了容器卷的容器來掛載資料卷。

docker run -d --name db3 --volumes-from db1 postgres

範例：備份

首先使用 --volumes-from 標記來建立一個載入 dbdata 容器卷的容器，並從本地主機掛載當前到容器的 /backup 目錄。

docker run --volumes-from dbdata -v $(pwd):/backup ubuntu tar cvf /backup/backup.tar /dbdata

範例：恢復

恢復資料到一個容器，首先建立一個帶有資料卷的容器 dbdata2

docker run -v /dbdata --name dbdata2 ubuntu /bin/bash

然後建立另一個容器，掛載 dbdata2 的容器，並使用 untar 解壓備份檔案到掛載的容器卷中。

docker run --volumes-from dbdata2 -v $(pwd):/backup busybox tar xvf /backup/backup.tar

Docker 中的網路功能介紹

• 要讓外部也可以存取這些應用
• 可以通過 -P 或 -p 參數來指定連接埠映射。

範例：隨機本機Port

docker run -d -P training/webapp python app.py

範例：指定本機Port

docker run -d -p 5000:5000 training/webapp python app.py

範例：綁定 localhost 的任意連接埠到容器的 5000 連接埠，本地主機會自動分配一個連接埠

docker run -d -p 127.0.0.1::5000 training/webapp python app.py

範例：還可以使用 udp 標記來指定 udp 連接埠

docker run -d -p 127.0.0.1:5000:5000/udp training/webapp python app.py

範例： -p 標記可以多次使用來綁定多個連接埠

docker run -d -p 5000:5000  -p 3000:80 training/webapp python app.py

Dockerfile 說明

• Dockerfile 由一行行命令語句組成，並且支援以 # 開頭的註解行。
• Dockerfile 分為四部分：
  • 基底映像檔資訊
  • 維護者資訊
  • 映像檔操作指令
  • 容器啟動時執行指令。

# This dockerfile uses the ubuntu image
# VERSION 2 - EDITION 1
# Author: docker_user
# Command format: Instruction [arguments / command] ..

# 基本映像檔，必須是第一個指令
FROM ubuntu

# 維護者： docker_user <docker_user at email.com> (@docker_user)
MAINTAINER docker_user docker_user@email.com

# 更新映像檔的指令
RUN echo "deb http://archive.ubuntu.com/ubuntu/ raring main universe" >> /etc/apt/sources.list
RUN apt-get update && apt-get install -y nginx
RUN echo "\ndaemon off;" >> /etc/nginx/nginx.conf

# 建立新容器時要執行的指令
CMD /usr/sbin/nginx

Dockerfile 基本語法

RUN 當命令較長時可以使用 \ 來換行。 RUN : 在 shell 終端中運行命令，即 /bin/sh -c； RUN ["executable", "param1", "param2"] : 使用 exec 執行。

CMD 指定啟動容器時執行的命令， 每個 Dockerfile 只能有一條 CMD 命令 。 如果指定了多條命令，只有最後一條會被執行。 CMD ["executable","param1","param2"] 使用 exec 執行，推薦使用； CMD command param1 param2 在 /bin/sh 中執行，使用在給需要互動的指令； CMD ["param1","param2"] 提供給 ENTRYPOINT 的預設參數；

ENTRYPOINT：每個 Dockerfile 中只能有一個 ENTRYPOINT，當指定多個時，只有最後一個會生效。 USER：要臨時取得管理員權限可以使用 gosu，而不推薦 sudo。 WORKDIR：可以使用多個 WORKDIR 指令，後續命令如果參數是相對路徑，則會基於之前命令指定的路徑

Docker File Base

# 映像檔Image
FROM python:3.11
# 維護者（已廢棄，建議使用 LABEL）
# MAINTAINER Pellok "pellok@double-cash.com"
LABEL maintainer="pellok@double-cash.com"
# 更新
RUN apt-get -y update && apt-get install -y supervisor
# 創建專案資料夾
RUN mkdir -p /usr/src/app
# 指定工作目錄在專案資料夾
WORKDIR /usr/src/app
# 預先要安裝的requirements複製到Docker裡面
COPY requirements.txt /usr/src/app/
# 安裝需要用的插件
RUN pip install --upgrade pip setuptools
RUN pip install --no-cache-dir -r requirements.txt
# 下次Build 的時候複製專案目錄到Docker 裡面
ONBUILD COPY . /usr/src/app

建置

docker build -t sample:base .

Docker File for Project

#  挑選Image
FROM sample:base
# 安裝cryptography
RUN pip install cryptography 
# 設定工作目錄
WORKDIR /usr/src/app/
# 執行Python Setup
RUN python setup.py develop
# 開啟Port號
EXPOSE 8082
# 執行專案
CMD pserve development.ini

建置

docker build -t project:v1 .

Pyramid 專案 Docker 化

#創建一個新專案
pcreate -s alchemy pyramid_dockerlize
cd pyramid_dockerlize
# 創建dockerfile
touch Dockerfile
# 編輯 Dockerfile
# 建置映像檔
docker build -t pyramid_dockerlize .
# 執行容器
docker run -d -P pyramid_dockerlize

Dockerfile

# This dockerfile uses the python pyramid
# VERSION 1 - EDITION 1
# Author: pellok
# Command describe

# 使用的python映像檔版本
FROM python:3.5

MAINTAINER pellok pellok@okborn.com

# 創建存放專案的資料夾
RUN mkdir -p /usr/src/app

# 複製當前目錄的所有檔案到容器內的，資料放在/usr/src/app
COPY . /usr/src/app

# 指定工作目錄
WORKDIR /usr/src/app/

# 安裝環境變數和相依性套件
RUN python setup.py develop

# 初始化DB
RUN initialize_pyramid_dockerlize_db development.ini

# 專案監聽的Port號
EXPOSE 6543

# 啟動專案
CMD pserve production.ini

要在 Docker 中安裝 Ubuntu 24.04 並登入 Bash，然後安裝 pip、python、vim、unzip 和 wget，你可以按照以下步驟操作：

1. 建立並啟動 Docker 容器

首先，在終端機中執行以下命令來從 Docker Hub 拉取 Ubuntu 24.04 的映像檔，並建立一個容器：

docker pull ubuntu:24.04
docker run -it --name ubuntu-container ubuntu:24.04 bash

這會將你帶入 Ubuntu 容器的 Bash 環境中。

2. 更新軟體包

在容器內，首先更新軟體包列表：

apt update

3. 安裝 Python, pip, vim, unzip, wget

接下來，安裝所需的軟體包：

apt install -y python3 python3-pip vim unzip wget

4. 驗證安裝

確認安裝是否成功：

python3 --version
pip3 --version
vim --version
unzip -v
wget --version

這些指令應該顯示安裝的版本資訊。

5. 保存和退出 Docker 容器

完成後，可以保存和退出容器：

exit

6. 再次進入容器

你可以隨時再次進入容器：

docker start ubuntu-container
docker exec -it ubuntu-container bash

這樣你就能再次進入並使用已安裝的軟體。

這個錯誤訊息是由於 Ubuntu 24.04 預設使用 "externally managed environment" 來管理 Python 軟體包，這意味著你不能直接使用 pip 在系統範圍內安裝 Python 軟體包（例如在全域範圍內）。這是因為使用 pip 安裝軟體包可能會和系統管理的 Python 軟體包產生衝突。

解決方案

你可以有以下幾個選項來解決這個問題：

1. 使用 apt 安裝 Python 軟體包

如果你需要安裝 Python 軟體包，建議使用 Ubuntu 的套件管理工具 apt：

apt install python3-pip

這樣可以避免和系統衝突，因為 apt 會使用預先打包好的軟體包版本。

2. 創建一個虛擬環境

如果你需要使用 pip 安裝一些系統沒有的 Python 軟體包，建議創建一個虛擬環境：

apt install python3-venv  # 首先安裝虛擬環境模組
python3 -m venv myenv     # 創建虛擬環境
source myenv/bin/activate # 啟用虛擬環境

在啟用虛擬環境後，使用 pip 安裝軟體包：

pip install <package_name>

當你不再需要虛擬環境時，可以執行 deactivate 來退出。

3. 使用 pipx 來安裝應用程式

如果你想安裝一個獨立的 Python 應用程式，可以使用 pipx 來安裝。首先安裝 pipx：

apt install pipx
pipx ensurepath

然後使用 pipx 安裝應用程式：

pipx install <application_name>

4. 使用 --break-system-packages 強制安裝（不推薦）

你也可以強制繞過這個限制，但這可能會導致系統不穩定或產生衝突，不推薦這樣做：

pip install <package_name> --break-system-packages

這種方式應謹慎使用，只適合那些了解其風險的用戶。

建議

建議使用虛擬環境 (venv) 或 pipx，這樣可以避免破壞系統環境，同時也能滿足你對 Python 軟體包的安裝需求。

參考

VM-for-Devops Virtual Box [VirtualBox5.1.8][Extension Pack] Vagrant[Vagrant1.8.7] kubernetes minikube

在dockerfile中設定時區

基於 Debian 鏡像

由於 Debian 鏡像中已經包含了tzdata，因此設定時區的方法比較簡單，只需新增環境變數TZ即可。

FROM debian:stretch

ENV TZ=Asia/Taipei

基於 Alpine 鏡像

FROM alpine:3.9

ENV TZ=Asia/Taipei

RUN apk update \
    && apk add tzdata \
    && echo "${TZ}" > /etc/timezone \
    && ln -sf /usr/share/zoneinfo/${TZ} /etc/localtime \
    && rm /var/cache/apk/*

基於 Ubuntu 鏡像

FROM ubuntu:bionic

ENV TZ=Asia/Taipei

RUN echo "${TZ}" > /etc/timezone \
    && ln -sf /usr/share/zoneinfo/${TZ} /etc/localtime \
    && apt update \
    && apt install -y tzdata \
    && rm -rf /var/lib/apt/lists/*

簡單範例

from pip import _internal
import time

if __name__ == '__main__':
    _internal.main(['list'])
    while True:
        print('Hello Docker world!')
        time.sleep(1)

FROM python:3.10-slim

# Add requirements file in the container
COPY requirements.txt ./requirements.txt
RUN pip install -r requirements.txt

# Add source code in the container
COPY main.py ./main.py

# Define container entry point (could also work with CMD python main.py)
ENTRYPOINT ["python", "main.py"]

• requirements.txt

requests
kafka-python
grpcio
protobuf
better-exceptions
loguru
pandas
python-binance
redis
aiohttp
flask
kubernetes

# 編譯 image
docker build -t my-image-name .  

# Run docker
docker run -it my-image-name

#查看 container_name or id
docker ps
79c7e6661fa2   my-image-name                     "python main.py"         54 seconds ago   Up 54 seconds                                                                                                    beautiful_khayyam

docker exec -it 79c7e6661fa2 /bin/bash
docker exec -it beautiful_khayyam /bin/bash

1. 使用命令行將上述 Dockerfile 文件保存在您的計算機上。

2. 創建 Docker 映像，請在命令行中導航到 Dockerfile 文件所在的目錄，並運行以下命令：

   docker build -t image_name .
   

   其中，image_name 是您要為映像命名的名稱，. 表示當前目錄是上下文。

3. 運行 Docker 映像，請使用以下命令：

   docker run -it --rm image_name
   

   其中，-it 表示要使用互動式終端來運行容器，--rm 表示當容器停止時，自動刪除容器。

4. 如果需要，在運行容器的情況下登入 Docker，請使用以下命令：

   docker exec -it container_name /bin/bash
   

   其中，container_name 是您要登入的容器的名稱，/bin/bash 是您要在容器中運行的命令。

希望這些命令可以幫助您成功編譯、運行和登入您的 Docker 映像。

Creating the Perfect Python Dockerfile

# using ubuntu LTS version
FROM ubuntu:20.04 AS builder-image

# avoid stuck build due to user prompt
ARG DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install --no-install-recommends -y python3.9 python3.9-dev python3.9-venv python3-pip python3-wheel build-essential && \
	apt-get clean && rm -rf /var/lib/apt/lists/*

# create and activate virtual environment
# using final folder name to avoid path issues with packages
RUN python3.9 -m venv /home/myuser/venv
ENV PATH="/home/myuser/venv/bin:$PATH"

# install requirements
COPY requirements.txt .
RUN pip3 install --no-cache-dir wheel
RUN pip3 install --no-cache-dir -r requirements.txt

FROM ubuntu:20.04 AS runner-image
RUN apt-get update && apt-get install --no-install-recommends -y python3.9 python3-venv && \
	apt-get clean && rm -rf /var/lib/apt/lists/*

RUN useradd --create-home myuser
COPY --from=builder-image /home/myuser/venv /home/myuser/venv

USER myuser
RUN mkdir /home/myuser/code
WORKDIR /home/myuser/code
COPY . .

EXPOSE 5000

# make sure all messages always reach console
ENV PYTHONUNBUFFERED=1

# activate virtual environment
ENV VIRTUAL_ENV=/home/myuser/venv
ENV PATH="/home/myuser/venv/bin:$PATH"

# /dev/shm is mapped to shared memory and should be used for gunicorn heartbeat
# this will improve performance and avoid random freezes
CMD ["gunicorn","-b", "0.0.0.0:5000", "-w", "4", "-k", "gevent", "--worker-tmp-dir", "/dev/shm", "app:app"]

https://luis-sena.medium.com/creating-the-perfect-python-dockerfile-51bdec41f1c8

由 Docker image 反推其 Dockerfile

當我們使用現成的 Docker image 進行開發時，有時候會想知道這個 image 的內容是什麼，他提供的功能是如何達成的，這個時候如果能找到作者提供的 Dockerfile 是最好，但如果對方沒有公開的話，就有點麻煩了，這時候我們可以使用內建的 docker history 指令根據每層 image layer 的 metadata 看出做的事情，此外也有大大做了現成的工具讓我們可以直接產出接近原本 Dockerfile 該有的內容。

這邊我拿了兩個工具來做實驗:

1. https://github.com/CenturyLinkLabs/dockerfile-from-image
2. https://github.com/lukapeschke/dockerfile-from-image

其中只有第二個是可行的，以下是實驗過程。

centurylink/dockerfile-from-imagePermalink

首先這個工具是參考這篇而看到的。 我先拿 ruby 嘗試一下:

$ docker pull centurylink/dockerfile-from-image
$ docker pull ruby
$ docker image | grep ruby
REPOSITORY                                    TAG                 IMAGE ID            CREATED              SIZE
docker.io/ruby                                latest              d529acb9f124        4 weeks ago          840 MB
$ docker run -v /var/run/docker.sock:/var/run/docker.sock centurylink/dockerfile-from-image d529acb9f124
/usr/lib/ruby/gems/2.2.0/gems/docker-api-1.24.1/lib/docker/connection.rb:42:in `rescue in request': 400 Bad Request: malformed Host header (Docker::Error::ClientError)
        from /usr/lib/ruby/gems/2.2.0/gems/docker-api-1.24.1/lib/docker/connection.rb:38:in `request'
        from /usr/lib/ruby/gems/2.2.0/gems/docker-api-1.24.1/lib/docker/connection.rb:65:in `block (2 levels) in <class:Connection>'
        from /usr/lib/ruby/gems/2.2.0/gems/docker-api-1.24.1/lib/docker/image.rb:172:in `all'
        from /usr/src/app/dockerfile-from-image.rb:32:in `<main>'

發現也有其他人碰到相同問題，參考這邊的說明，利用他給的 Dockerfile 重新 build image 之後，反倒無法輸出任何東西。這個 repository 最近一次更新也是 2015 的事了，該工具似已不再適用新版的 Docker。

lukapeschke/dockerfile-from-imagePermalink

參考上面同的討論串後續的內容找到第二個 repository，用他的 Dockerfile 來 build image:

$ git clone https://github.com/lukapeschke/dockerfile-from-image.git
$ cd dockerfile-from-image/
$ docker build --rm -t lukapeschke/dockerfile-from-image .

他的使用方法 (只能用 image ID，不能用 image name!):

$ docker run --rm -v '/var/run/docker.sock:/var/run/docker.sock' lukapeschke/dockerfile-from-image <IMAGE_ID>

以下拿 ruby 測試可以順利產生我們要的:

$ docker run --rm -v '/var/run/docker.sock:/var/run/docker.sock' lukapeschke/dockerfile-from-image d529acb9f124
FROM docker.io/ruby:latest
ADD file:2cddee716e84c40540a69c48051bd2dcf6cd3bd02a3e399334e97f20a77126ff in /
CMD ["bash"]
RUN /bin/sh -c apt-get update \
    && apt-get install -y --no-install-recommends 		ca-certificates 		curl 		netbase 		wget 	\
    && rm -rf /var/lib/apt/lists/*
RUN /bin/sh -c set -ex; 	if ! command -v gpg > /dev/null; then 		apt-get update; 		apt-get install -y --no-install-recommends 			gnupg 			dirmngr 		; 		rm -rf /var/lib/apt/lists/*; 	fi
RUN /bin/sh -c apt-get update \
    && apt-get install -y --no-install-recommends 		git 		mercurial 		openssh-client 		subversion 	procps 	\
    && rm -rf /var/lib/apt/lists/*
RUN /bin/sh -c set -ex; 	apt-get update; 	apt-get install -y --no-install-recommends 		autoconf 		automake 		bzip2 		dpkg-dev 		file 		g++ 		gcc 		imagemagick 		libbz2-dev 	libc6-dev 		libcurl4-openssl-dev 		libdb-dev 		libevent-dev 		libffi-dev 		libgdbm-dev 	libgeoip-dev 		libglib2.0-dev 		libgmp-dev 		libjpeg-dev 		libkrb5-dev 		liblzma-dev 		libmagickcore-dev 		libmagickwand-dev 		libncurses5-dev 		libncursesw5-dev 		libpng-dev 	libpq-dev 		libreadline-dev 		libsqlite3-dev 		libssl-dev 		libtool 		libwebp-dev 	libxml2-dev 		libxslt-dev 		libyaml-dev 		make 		patch 		unzip 		xz-utils 		zlib1g-dev 				$( 			if apt-cache show 'default-libmysqlclient-dev' 2>/dev/null | grep -q '^Version:'; then 				echo 'default-libmysqlclient-dev'; 			else 				echo 'libmysqlclient-dev'; 			fi 		) 	; 	rm -rf /var/lib/apt/lists/*
RUN /bin/sh -c set -eux; 	mkdir -p /usr/local/etc; 	{ 		echo 'install: --no-document'; 		echo 'update: --no-document'; 	} >> /usr/local/etc/gemrc
ENV RUBY_MAJOR=2.6
ENV RUBY_VERSION=2.6.3
ENV RUBY_DOWNLOAD_SHA256=11a83f85c03d3f0fc9b8a9b6cad1b2674f26c5aaa43ba858d4b0fcc2b54171e1
RUN /bin/sh -c set -eux; 		savedAptMark="$(apt-mark showmanual)"; 	apt-get update; 	apt-get install -y --no-install-recommends 		bison 		dpkg-dev 		libgdbm-dev 		ruby 	; 	rm -rf /var/lib/apt/lists/*; 		wget -O ruby.tar.xz "https://cache.ruby-lang.org/pub/ruby/${RUBY_MAJOR%-rc}/ruby-$RUBY_VERSION.tar.xz"; 	echo "$RUBY_DOWNLOAD_SHA256 *ruby.tar.xz" | sha256sum --check --strict; 		mkdir -p /usr/src/ruby; 	tar -xJf ruby.tar.xz -C /usr/src/ruby --strip-components=1; 	rm ruby.tar.xz; 		cd /usr/src/ruby; 		{ 		echo '#define ENABLE_PATH_CHECK 0'; 		echo; 		cat file.c; 	} > file.c.new; 	mv file.c.new file.c; 		autoconf; 	gnuArch="$(dpkg-architecture --query DEB_BUILD_GNU_TYPE)"; 	./configure 		--build="$gnuArch" 		--disable-install-doc 		--enable-shared 	; 	make -j "$(nproc)"; 	make install; 		apt-mark auto '.*' > /dev/null; 	apt-mark manual $savedAptMark > /dev/null; 	find /usr/local -type f -executable -not \( -name '*tkinter*' \) -exec ldd '{}' ';' 		| awk '/=>/ { print $(NF-1) }' 		| sort -u 		| xargs -r dpkg-query --search 		| cut -d: -f1 		| sort -u 		| xargs -r apt-mark manual 	; 	apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false; 		cd /; 	rm -r /usr/src/ruby; 	! dpkg -l | grep -i ruby; 	[ "$(command -v ruby)" = '/usr/local/bin/ruby' ]; 	ruby --version; 	gem --version; 	bundle --version
ENV GEM_HOME=/usr/local/bundle
ENV BUNDLE_PATH=/usr/local/bundle BUNDLE_SILENCE_ROOT_WARNING=1 BUNDLE_APP_CONFIG=/usr/local/bundle
ENV PATH=/usr/local/bundle/bin:/usr/local/bundle/gems/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
RUN /bin/sh -c mkdir -p "$GEM_HOME" \
    && chmod 777 "$GEM_HOME"
CMD ["irb"]

不過可惜的是像這樣的工具終究無法還原出真實 Dockerfile 中 COPY 或 ADD 的時候加入到 image 中的檔案。 例如以下是用該工具還原他自己:

$ docker images | grep "lukapeschke/dockerfile-from-image"
lukapeschke/dockerfile-from-image             latest              d719f8dcb798        37 minutes ago      59 MB

$ docker run -v /var/run/docker.sock:/var/run/docker.sock lukapeschke/dockerfile-from-image d719f8dcb798
FROM docker.io/alpine:latest
RUN /bin/sh -c apk add --update python3 wget      \
    && wget -O - --no-check-certificate https://bootstrap.pypa.io/get-pip.py | python3      \
    && apk del wget      \
    && pip3 install -U docker-py      \
    && yes | pip3 uninstall pip
COPY file:d7369c0379dc34ec79c308a782b14eab9c86ed1ebc41b5ce859e32760518fb21 in /root
ENTRYPOINT ["/root/entrypoint.py"]

可以看到 COPY 的部分只能知道有檔案被複製到指定目錄而已。

python 連接 redis

出處:https://cloud.tencent.com/developer/article/1892663

redis 安裝

先確保redis 已經安裝並且啟動

(host port):(docker port)

docker pull redis:latest
docker run -itd --name redis-test -p 1234:6379 redis

docker ps

CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                                       NAMES
5ccd903da485   redis     "docker-entrypoint.s…"   6 minutes ago   Up 6 minutes   0.0.0.0:1234->6379/tcp, :::1234->6379/tcp   redis-test

進入docker容器

docker exec -it redis-test /bin/bash

進入容器後，可以使用redis-cli 命令redis-cli SET key value的值,redis-cli GET key取出對應的值

root@ec62efc510ce:/data# redis-cli SET yoyo "hello world"
OK
root@ec62efc510ce:/data# redis-cli GET yoyo              
"hello world"

經過簡單的測試，說明沒有問題

python 連 reids

接著講下如何用 python 程式碼連上 redis 資料庫服務器。 先使用pip 安裝redis 驅動包

pip install redis

程式碼很簡單

import redis
r = redis.StrictRedis(host='127.0.0.1', port=1234)
print(r.get('yoyo'))

運行結果是byte類型：b'hello world'，可以加個參數decode_responses=True,設定得到str字串

import redis
r = redis.StrictRedis(host='127.0.0.1', port=1234, decode_responses=True)
print(r.get('yoyo'))

於是可以得到字串:yoyo

測試下set新增鍵值對，get取值，中文也是沒問題的

import redis
r = redis.StrictRedis(host='127.0.0.1', port=1234, decode_responses=True)

# set 設定key-value
r.set("name", "上海-悠悠")
print(r.get("name"))

運行結果:上海-悠悠

當key不存在的時候，get()取值返回結果是None

Python Docker 容器與 Redis Docker 容器 連動

docker redis 安裝

docker pull redis:latest

由於您的 Python Docker 容器與 Redis Docker 容器不在同一個 Docker 網路上，因此您需要將 Python Docker 容器加入相同的 Docker 網路。您可以使用以下命令創建一個名為 my-network 的 Docker 網路：

docker network create my-network

然後，您可以使用以下命令運行 Python Docker 容器，並將其加入 my-network 網路：

docker run -itd --name redis-test -p 1234:6379 --network my-network <image_name>  使用 docker images 查看

docker run -itd --name redis-test -p 1234:6379 --network my-network redis

Build the python docker image:

• requirements.txt

requests
kafka-python
grpcio
protobuf
better-exceptions
loguru
pandas
python-binance
redis
aiohttp
flask
kubernetes

• Dockerfile

FROM python:3.11-slim

# Add requirements file in the container
COPY requirements.txt ./requirements.txt
RUN pip install -r requirements.txt

# Add source code in the container
COPY redis_test_script.py ./redis_test_script.py

# Define container entry point (could also work with CMD python main.py)
ENTRYPOINT ["python", "redis_test_script.py"]

在 Python 應用程式中使用 Redis 容器的 IP 位置，而不是使用 127.0.0.1。由於 Redis 容器的名稱為 redis-test，因此您可以使用以下程式碼來連接 Redis 服務：

• redis_test_script.py

import redis
r = redis.StrictRedis(host='redis-test', port=6379, decode_responses=True)

# set 設定key-value
r.set("name", "上海-悠悠")
print(r.get("name"))

在這個命令中，-t 參數指定映像檔的名稱

docker build -t python-redis .

docker run -d --network=my-network --name my-db redis ...
docker run    --network=my-network python-redis ...

第一個指令 docker run -d --network=my-network --name my-db redis ... 是用來運行 Redis Docker 容器。這個指令中的 --network=my-network 參數表示將容器連接到 Docker 網路 my-network 中，因此其他 Docker 容器可以通過這個網路訪問 Redis 容器。 --name my-db 參數為容器指定了一個名稱 my-db，方便後續使用。redis 表示我們要使用的 Docker 映像檔名稱和版本。最後的 ... 表示可以在這個命令後面加上其他的參數來運行 Redis 容器。

第二個指令 docker run --network=my-network python-redis ... 是用來運行 Python Docker 容器。這個指令中的 --network=my-network 參數表示將容器連接到 Docker 網路 my-network 中，這樣 Python 容器就可以通過這個網路訪問 Redis 容器。 python-redis 表示我們要使用的 Docker 映像檔名稱和版本。最後的 ... 表示可以在這個命令後面加上其他的參數來運行 Python 容器。

在這兩個指令中，--network 參數用於指定容器所使用的 Docker 網路，讓不同的容器可以在同一個網路中進行通信。 --name 參數用於指定容器的名稱，方便後續使用。而最後的 ... 可以用於指定其他的參數，例如指定容器運行的命令等等。

Docker connect to host

docker build -t python-redis .

docker run --network=host -it  python-redis

Docker 容器內部的 Python 程式直接連接到宿主機器上運行的 Redis 服務。請注意，使用 --network=host 參數可能會降低容器的安全性，因為容器可以訪問宿主機器上的所有網路資源。因此，建議在必要時才使用這個參數。

import redis

r = redis.StrictRedis(host='127.0.0.1', port=6379, decode_responses=True)
# set 設定key-value
r.set("name", "上海-悠悠 127.0.0.1")
print(r.get("name"))

Docker 常用的指令

image

如果要搜索 image 可以上 dockerhub 找(裡面都有可以直接抓下來的指令)

docker pull image_name
# 從 Dockerhub 拉回 image
docker images
docker image ls
# 列出本地 image
docker rmi (image_name or image_id)
#移除 image

Container

# 查看本地 container
# -a：顯示所有執行中的 container。
docker ps (-a)
docker container ls (-a)
# 執行 container
docker start (container_id or container_name)
# 離開 container
exit  (退出並停止容器)
# 停止 container
docker stop (container_id or container_name)
# 移除 container
docker rm (container_id or container_name)

volume

將本機的某個位置掛載至 Container 的某個位置。

# 列出本地 volume
docker volume ls
# 移除 volume
docker volume rm volume_name

# 移除所有未使用的 volume
docker volume prune

清理Docker的container，image與volume

出處: https://note.qidong.name/2017/06/26/docker-clean/

Docker的鏡像（image）、容器（container）、資料卷（volume）， 都是由daemon託管的。 因此，在需要清理時，也需要使用其自帶的手段。

清理技巧 ¶

清理所有停止運行的容器：

docker container prune
# or
docker rm $(docker ps -aq)

清理所有懸掛（<none>）鏡像：

docker image prune
# or
docker rmi $(docker images -qf "dangling=true")

清理所有無用資料卷：

docker volume prune

由於prune操作是批次刪除類的危險操作，所以會有一次確認。 如果不想輸入y<CR>來確認，可以新增-f操作。慎用！

清理停止的容器 ¶

docker rm -lv CONTAINER

-l是清理link，v是清理volume。 這裡的CONTAINER是容器的name或ID，可以是一個或多個。

參數列表：

清理所有停止的容器 ¶

通過docker ps可以查詢當前運行的容器資訊。 而通過docker ps -a，可以查詢所有的容器資訊，包括已停止的。

在需要清理所有已停止的容器時，通常利用shell的特性，組合一下就好。

docker rm $(docker ps -aq)

其中，ps的-q，是隻輸出容器ID，方便作為參數讓rm使用。 假如給rm指定-f，則可以清理所有容器，包括正在運行的。

這條組合命令，等價於另一條命令：

docker container prune

container子命令，下面包含了所有和容器相關的子命令。 包括docker ps，等價於docker container ps或docker container ls。 其餘還有start、stop、kill、cp等，一級子命令相當於二級子命令在外面的alias。 而prune則是特別提供的清理命令，這在其它的管理命令裡還可以看到，比如image、volume。

按需批次清理容器 ¶

清除所有已停止的容器，是比較常用的清理。 但有時會需要做一些特殊過濾。

這時就需要使用docker ps --filter。

比如，顯示所有返回值為0，即正常退出的容器：

docker ps -a --filter 'exited=0'

同理，可以得到其它非正常退出的容器。

目前支援的過濾器有：

• id (container’s id)
• label (label=<key> or label=<key>=<value>)
• name (container’s name)
• exited (int - the code of exited containers. Only useful with –all)
• status (created|restarting|running|removing|paused|exited|dead)
• ancestor (<image-name>[:<tag>], <image id> or <image@digest>) - filters containers that were created from the given image or a descendant.
• before (container’s id or name) - filters containers created before given id or name
• since (container’s id or name) - filters containers created since given id or name
• isolation (default|process|hyperv) (Windows daemon only)
• volume (volume name or mount point) - filters containers that mount volumes.
• network (network id or name) - filters containers connected to the provided network
• health (starting|healthy|unhealthy|none) - filters containers based on healthcheck status

清理失敗 ¶

如果在清理容器時發生失敗，通過重啟Docker的Daemon，應該都能解決問題。

# systemd
sudo systemctl restart docker.service

# initd
sudo service docker restart

清理鏡像 ¶

與清理容器的ps、rm類似，清理鏡像也有images、rmi兩個子命令。 images用來查看，rmi用來刪除。

清理鏡像前，應該確保該鏡像的容器，已經被清除。

docker rmi IMAGE

其中，IMAGE可以是name或ID。 如果是name，不加TAG可以刪除所有TAG。

另外，這兩個命令也都屬於alias。 docker images等價於docker image ls，而docker rmi等價於docker image rm。

按需批次清理鏡像 ¶

與ps類似，images也支援--filter參數。

與清理相關，最常用的，當屬<none>了。

docker images --filter "dangling=true"

這條命令，可以列出所有懸掛（dangling）的鏡像，也就是顯示為<none>的那些。

docker rmi $(docker images -qf "dangling=true")

這條組合命令，如果不寫入Bash的alias，幾乎無法使用。 不過還有一條等價命令，非常容易使用。

docker image prune

prune和images類似，也同樣支援--filter參數。 其它的filter有：

• dangling (boolean - true or false)
• label (label=<key> or label=<key>=<value>)
• before (<image-name>[:<tag>], <image id> or <image@digest>) - filter images created before given id or references
• since (<image-name>[:<tag>], <image id> or <image@digest>) - filter images created since given id or references
• reference (pattern of an image reference) - filter images whose reference matches the specified pattern

清理所有無用鏡像 ¶

這招要慎用，否則需要重新下載。

docker image prune -a

清理資料卷 ¶

資料卷不如容器或鏡像那樣顯眼，但佔的硬碟卻可大可小。

資料卷的相關命令，都在docker volume中了。

一般用docker volume ls來查看，用docker volume rm VOLUME來刪除一個或多個。

不過，絕大多數情況下，不需要執行這兩個命令的組合。 直接執行docker volume prune就好，即可刪除所有無用卷。

注意：這是一個危險操作！甚至可以說，這是本文中最危險的操作！ 一般真正有價值的運行資料，都在資料卷中。 （當然也可能掛載到了容器外的檔案系統裡，那就沒關係。） 如果在關鍵服務停止期間，執行這個操作，很可能會丟失所有資料！

從檔案系統刪除 ¶

除組態檔案以為，Docker的內容相關檔案，基本都放在/var/lib/docker/目錄下。

該目錄下有下列子目錄，基本可以猜測出用途：

• aufs
• containers
• image
• network
• plugins
• swarm
• tmp
• trust
• volumes

一般不推薦直接操作這些目錄，除非一些極特殊情況。 操作不當，後果難料，需要慎重。

這兩個 Docker 命令的差異在於它們的目的和執行方式。

docker run -it --rm redis bash 
docker exec -it redis sh

• docker run -it --rm redis bash 命令的目的是啟動一個 Redis 容器，然後在容器中執行一個交互式 Bash shell。這個命令會建立一個新的容器，並且在容器內啟動一個新的 Bash shell。在這個 shell 中，您可以在容器內進行任何操作，就像在一個本地的 Bash shell 中一樣。這個容器會在退出 shell 後立即被刪除，因為我們使用了 --rm 選項。
• docker exec -it redis sh 命令的目的是在一個已經運行的 Redis 容器中執行一個新的交互式 shell。這個命令不會創建新的容器，而是在現有的 Redis 容器內運行一個新的 shell。因此，使用這個命令，您必須先啟動一個 Redis 容器。在 shell 中，您可以在容器內進行任何操作，並且這些操作將會對容器內的系統環境進行更改。該容器不會被刪除，因為我們沒有使用 --rm 選項。

簡而言之，docker run 命令用於啟動新容器，而 docker exec 命令則用於在現有容器中運行命令。

使用 Docker-Compose 啟動多個 Docker Container

出處：https://ithelp.ithome.com.tw/articles/10194183

今天要介紹有關於 Docker-Compose 的部份，之前有介紹過使用 docker run 指令就可以把 Docker Container 啟動起來，但是如果我們要啟動很多個 Docker Container 時，就需要輸入很多次 docker run 指令，另外 container 和 container 之間要做關聯的話也要記得它們之間要如何的連結(link) Container，這樣在要啟動多個 Container 的情況下，就會顯得比較麻煩。

因此就出現了 Docker-Compose，只要寫一個 docker-compose.yml，把所有要使用 Docker Image 寫上去，另外也可以把 Container 之間的關係連結(link)起來，最後只要下 docker-compose up 指令，就可以把所有的 Docker Container 執行起來，這樣就可以很快速和方便的啟動多個 container。

實作的部份主要就是要把 Docker-Compose 安裝起來，然後撰寫一個 docker-compose.yml，並且使用 docker-compose up，指令把所有的 Docker Container 啟動起來，步驟如下：

1. 安裝 Docker-Compose，指令如下

https://github.com/docker/compose/releases/

sudo curl -L "https://github.com/docker/compose/releases/download/v2.6.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# cd /usr/bin
# wget https://github.com/docker/compose/releases/download/1.18.0/docker-compose-Linux-x86_64
# mv docker-compose-Linux-x86_64 docker-compose
# chmod 755 docker-compose

2. 撰寫 docker-compose.yml 檔案如下

version: '2'
services:
  db:
     image: mysql
     environment:
        MYSQL_ROOT_PASSWORD: 123456
  admin:
     image: adminer
     ports:
       - 8080:8080

這個 docker-compose.yml 的檔案，是參考以下網站，改寫出來的 https://hub.docker.com/_/mysql/

主要的功能是要啟動 2 個 Docker Container，一個是 mysql 的 Container，另外一個是 admin 管理 mysql Web UI 的 container

MYSQL_ROOT_PASSWORD 的環境變數用來設定登入 mysql 的密碼

3. 啟動所有的 Docker Container 指令如下

$ docker-compose up -d

執行所有在 docker-compose.yml 檔案裡面設定的 Docker Image 啟動 Docker Container，另外 -d 參數代表要執行在背景的方式

4. 使用 Docker-Compose 提供的指令查看 Docker Container 的執行狀態

$ docker-compose ps

要輸入此指令之前，要先把資料夾切到和 docker-compose.yml 同一層的資料夾路徑下面，執行結果如下

5. admin 執行的畫面如下

帳號輸入 root 和密碼輸入 123456，之後就可以登入 mysql 的管理畫面，畫面如下：

6. 如果要看執行的 log 可以使用以下的指令

$ docker-compose logs

另外 logs 後面可以加上 Container Name 畫面如下

7. 如果要停止 docker-compose 執行的所有 Container 可以使用以下的指令

$ docker-compose stop

8. 如果要刪除 docker-compose 的所有 Container 可以使用以下的指令

$ docker-compose rm

畫面如下

今天介紹的 Docker-Compose 可以很方便的讓我們在執行啟動多個 Container，其實 docker-compose.yml，還有很多的寫法沒有介紹到，因此有興趣的話可以參考官方網站的說明，網址如下： https://docs.docker.com/compose/compose-file/compose-file-v2/

docker-compse 安裝 Redis

• Run

  docker-compose -f docker-compose.yml up -d
  

• test.py

  import redis
  
  r = redis.StrictRedis(host='127.0.0.1', port=1234, password='12345678')
  print(r.get('yoyo'))
  

• docker-compose.yml

  version: '3.3'
  services:
    redis:
      image: redis
      container_name: redis
      command: redis-server /usr/local/etc/redis/redis.conf
      ports:
        - "1234:6379"
      volumes:
        - ./data:/data
        - ./redis.conf:/usr/local/etc/redis/redis.conf
  

  redis.conf

  # Redis configuration file example.
  #
  # Note that in order to read the configuration file, Redis must be
  # started with the file path as first argument:
  #
  # ./redis-server /path/to/redis.conf
  
  # Note on units: when memory size is needed, it is possible to specify
  # it in the usual form of 1k 5GB 4M and so forth:
  #
  # 1k => 1000 bytes
  # 1kb => 1024 bytes
  # 1m => 1000000 bytes
  # 1mb => 1024*1024 bytes
  # 1g => 1000000000 bytes
  # 1gb => 1024*1024*1024 bytes
  #
  # units are case insensitive so 1GB 1Gb 1gB are all the same.
  
  ################################## INCLUDES ###################################
  
  # Include one or more other config files here.  This is useful if you
  # have a standard template that goes to all Redis servers but also need
  # to customize a few per-server settings.  Include files can include
  # other files, so use this wisely.
  #
  # Notice option "include" won't be rewritten by command "CONFIG REWRITE"
  # from admin or Redis Sentinel. Since Redis always uses the last processed
  # line as value of a configuration directive, you'd better put includes
  # at the beginning of this file to avoid overwriting config change at runtime.
  #
  # If instead you are interested in using includes to override configuration
  # options, it is better to use include as the last line.
  #
  # include /path/to/local.conf
  # include /path/to/other.conf
  
  ################################## MODULES #####################################
  
  # Load modules at startup. If the server is not able to load modules
  # it will abort. It is possible to use multiple loadmodule directives.
  #
  # loadmodule /path/to/my_module.so
  # loadmodule /path/to/other_module.so
  
  ################################## NETWORK #####################################
  
  # By default, if no "bind" configuration directive is specified, Redis listens
  # for connections from all the network interfaces available on the server.
  # It is possible to listen to just one or multiple selected interfaces using
  # the "bind" configuration directive, followed by one or more IP addresses.
  #
  # Examples:
  #
  # bind 192.168.1.100 10.0.0.1
  # bind 127.0.0.1 ::1
  #
  # ~~~ WARNING ~~~ If the computer running Redis is directly exposed to the
  # internet, binding to all the interfaces is dangerous and will expose the
  # instance to everybody on the internet. So by default we uncomment the
  # following bind directive, that will force Redis to listen only into
  # the IPv4 loopback interface address (this means Redis will be able to
  # accept connections only from clients running into the same computer it
  # is running).
  #
  # IF YOU ARE SURE YOU WANT YOUR INSTANCE TO LISTEN TO ALL THE INTERFACES
  # JUST COMMENT THE FOLLOWING LINE.
  # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # bind 127.0.0.1
  
  # Protected mode is a layer of security protection, in order to avoid that
  # Redis instances left open on the internet are accessed and exploited.
  #
  # When protected mode is on and if:
  #
  # 1) The server is not binding explicitly to a set of addresses using the
  #    "bind" directive.
  # 2) No password is configured.
  #
  # The server only accepts connections from clients connecting from the
  # IPv4 and IPv6 loopback addresses 127.0.0.1 and ::1, and from Unix domain
  # sockets.
  #
  # By default protected mode is enabled. You should disable it only if
  # you are sure you want clients from other hosts to connect to Redis
  # even if no authentication is configured, nor a specific set of interfaces
  # are explicitly listed using the "bind" directive.
  protected-mode yes
  
  # Accept connections on the specified port, default is 6379 (IANA #815344).
  # If port 0 is specified Redis will not listen on a TCP socket.
  port 6379
  
  # TCP listen() backlog.
  #
  # In high requests-per-second environments you need an high backlog in order
  # to avoid slow clients connections issues. Note that the Linux kernel
  # will silently truncate it to the value of /proc/sys/net/core/somaxconn so
  # make sure to raise both the value of somaxconn and tcp_max_syn_backlog
  # in order to get the desired effect.
  tcp-backlog 511
  
  # Unix socket.
  #
  # Specify the path for the Unix socket that will be used to listen for
  # incoming connections. There is no default, so Redis will not listen
  # on a unix socket when not specified.
  #
  # unixsocket /tmp/redis.sock
  # unixsocketperm 700
  
  # Close the connection after a client is idle for N seconds (0 to disable)
  timeout 0
  
  # TCP keepalive.
  #
  # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence
  # of communication. This is useful for two reasons:
  #
  # 1) Detect dead peers.
  # 2) Take the connection alive from the point of view of network
  #    equipment in the middle.
  #
  # On Linux, the specified value (in seconds) is the period used to send ACKs.
  # Note that to close the connection the double of the time is needed.
  # On other kernels the period depends on the kernel configuration.
  #
  # A reasonable value for this option is 300 seconds, which is the new
  # Redis default starting with Redis 3.2.1.
  tcp-keepalive 300
  
  ################################# GENERAL #####################################
  
  # By default Redis does not run as a daemon. Use 'yes' if you need it.
  # Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
  daemonize no
  
  # If you run Redis from upstart or systemd, Redis can interact with your
  # supervision tree. Options:
  #   supervised no      - no supervision interaction
  #   supervised upstart - signal upstart by putting Redis into SIGSTOP mode
  #   supervised systemd - signal systemd by writing READY=1 to $NOTIFY_SOCKET
  #   supervised auto    - detect upstart or systemd method based on
  #                        UPSTART_JOB or NOTIFY_SOCKET environment variables
  # Note: these supervision methods only signal "process is ready."
  #       They do not enable continuous liveness pings back to your supervisor.
  supervised no
  
  # If a pid file is specified, Redis writes it where specified at startup
  # and removes it at exit.
  #
  # When the server runs non daemonized, no pid file is created if none is
  # specified in the configuration. When the server is daemonized, the pid file
  # is used even if not specified, defaulting to "/var/run/redis.pid".
  #
  # Creating a pid file is best effort: if Redis is not able to create it
  # nothing bad happens, the server will start and run normally.
  pidfile /var/run/redis_6379.pid
  
  # Specify the server verbosity level.
  # This can be one of:
  # debug (a lot of information, useful for development/testing)
  # verbose (many rarely useful info, but not a mess like the debug level)
  # notice (moderately verbose, what you want in production probably)
  # warning (only very important / critical messages are logged)
  loglevel notice
  
  # Specify the log file name. Also the empty string can be used to force
  # Redis to log on the standard output. Note that if you use standard
  # output for logging but daemonize, logs will be sent to /dev/null
  logfile ""
  
  # To enable logging to the system logger, just set 'syslog-enabled' to yes,
  # and optionally update the other syslog parameters to suit your needs.
  # syslog-enabled no
  
  # Specify the syslog identity.
  # syslog-ident redis
  
  # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
  # syslog-facility local0
  
  # Set the number of databases. The default database is DB 0, you can select
  # a different one on a per-connection basis using SELECT <dbid> where
  # dbid is a number between 0 and 'databases'-1
  databases 16
  
  # By default Redis shows an ASCII art logo only when started to log to the
  # standard output and if the standard output is a TTY. Basically this means
  # that normally a logo is displayed only in interactive sessions.
  #
  # However it is possible to force the pre-4.0 behavior and always show a
  # ASCII art logo in startup logs by setting the following option to yes.
  always-show-logo yes
  
  ################################ SNAPSHOTTING  ################################
  #
  # Save the DB on disk:
  #
  #   save <seconds> <changes>
  #
  #   Will save the DB if both the given number of seconds and the given
  #   number of write operations against the DB occurred.
  #
  #   In the example below the behaviour will be to save:
  #   after 900 sec (15 min) if at least 1 key changed
  #   after 300 sec (5 min) if at least 10 keys changed
  #   after 60 sec if at least 10000 keys changed
  #
  #   Note: you can disable saving completely by commenting out all "save" lines.
  #
  #   It is also possible to remove all the previously configured save
  #   points by adding a save directive with a single empty string argument
  #   like in the following example:
  #
  #   save ""
  
  save 900 1
  save 300 10
  save 60 10000
  
  # By default Redis will stop accepting writes if RDB snapshots are enabled
  # (at least one save point) and the latest background save failed.
  # This will make the user aware (in a hard way) that data is not persisting
  # on disk properly, otherwise chances are that no one will notice and some
  # disaster will happen.
  #
  # If the background saving process will start working again Redis will
  # automatically allow writes again.
  #
  # However if you have setup your proper monitoring of the Redis server
  # and persistence, you may want to disable this feature so that Redis will
  # continue to work as usual even if there are problems with disk,
  # permissions, and so forth.
  stop-writes-on-bgsave-error yes
  
  # Compress string objects using LZF when dump .rdb databases?
  # For default that's set to 'yes' as it's almost always a win.
  # If you want to save some CPU in the saving child set it to 'no' but
  # the dataset will likely be bigger if you have compressible values or keys.
  rdbcompression yes
  
  # Since version 5 of RDB a CRC64 checksum is placed at the end of the file.
  # This makes the format more resistant to corruption but there is a performance
  # hit to pay (around 10%) when saving and loading RDB files, so you can disable it
  # for maximum performances.
  #
  # RDB files created with checksum disabled have a checksum of zero that will
  # tell the loading code to skip the check.
  rdbchecksum yes
  
  # The filename where to dump the DB
  dbfilename dump.rdb
  
  # The working directory.
  #
  # The DB will be written inside this directory, with the filename specified
  # above using the 'dbfilename' configuration directive.
  #
  # The Append Only File will also be created inside this directory.
  #
  # Note that you must specify a directory here, not a file name.
  dir ./
  
  ################################# REPLICATION #################################
  
  # Master-Replica replication. Use replicaof to make a Redis instance a copy of
  # another Redis server. A few things to understand ASAP about Redis replication.
  #
  #   +------------------+      +---------------+
  #   |      Master      | ---> |    Replica    |
  #   | (receive writes) |      |  (exact copy) |
  #   +------------------+      +---------------+
  #
  # 1) Redis replication is asynchronous, but you can configure a master to
  #    stop accepting writes if it appears to be not connected with at least
  #    a given number of replicas.
  # 2) Redis replicas are able to perform a partial resynchronization with the
  #    master if the replication link is lost for a relatively small amount of
  #    time. You may want to configure the replication backlog size (see the next
  #    sections of this file) with a sensible value depending on your needs.
  # 3) Replication is automatic and does not need user intervention. After a
  #    network partition replicas automatically try to reconnect to masters
  #    and resynchronize with them.
  #
  # replicaof <masterip> <masterport>
  
  # If the master is password protected (using the "requirepass" configuration
  # directive below) it is possible to tell the replica to authenticate before
  # starting the replication synchronization process, otherwise the master will
  # refuse the replica request.
  #
  # masterauth <master-password>
  
  # When a replica loses its connection with the master, or when the replication
  # is still in progress, the replica can act in two different ways:
  #
  # 1) if replica-serve-stale-data is set to 'yes' (the default) the replica will
  #    still reply to client requests, possibly with out of date data, or the
  #    data set may just be empty if this is the first synchronization.
  #
  # 2) if replica-serve-stale-data is set to 'no' the replica will reply with
  #    an error "SYNC with master in progress" to all the kind of commands
  #    but to INFO, replicaOF, AUTH, PING, SHUTDOWN, REPLCONF, ROLE, CONFIG,
  #    SUBSCRIBE, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, PUBLISH, PUBSUB,
  #    COMMAND, POST, HOST: and LATENCY.
  #
  replica-serve-stale-data yes
  
  # You can configure a replica instance to accept writes or not. Writing against
  # a replica instance may be useful to store some ephemeral data (because data
  # written on a replica will be easily deleted after resync with the master) but
  # may also cause problems if clients are writing to it because of a
  # misconfiguration.
  #
  # Since Redis 2.6 by default replicas are read-only.
  #
  # Note: read only replicas are not designed to be exposed to untrusted clients
  # on the internet. It's just a protection layer against misuse of the instance.
  # Still a read only replica exports by default all the administrative commands
  # such as CONFIG, DEBUG, and so forth. To a limited extent you can improve
  # security of read only replicas using 'rename-command' to shadow all the
  # administrative / dangerous commands.
  replica-read-only yes
  
  # Replication SYNC strategy: disk or socket.
  #
  # -------------------------------------------------------
  # WARNING: DISKLESS REPLICATION IS EXPERIMENTAL CURRENTLY
  # -------------------------------------------------------
  #
  # New replicas and reconnecting replicas that are not able to continue the replication
  # process just receiving differences, need to do what is called a "full
  # synchronization". An RDB file is transmitted from the master to the replicas.
  # The transmission can happen in two different ways:
  #
  # 1) Disk-backed: The Redis master creates a new process that writes the RDB
  #                 file on disk. Later the file is transferred by the parent
  #                 process to the replicas incrementally.
  # 2) Diskless: The Redis master creates a new process that directly writes the
  #              RDB file to replica sockets, without touching the disk at all.
  #
  # With disk-backed replication, while the RDB file is generated, more replicas
  # can be queued and served with the RDB file as soon as the current child producing
  # the RDB file finishes its work. With diskless replication instead once
  # the transfer starts, new replicas arriving will be queued and a new transfer
  # will start when the current one terminates.
  #
  # When diskless replication is used, the master waits a configurable amount of
  # time (in seconds) before starting the transfer in the hope that multiple replicas
  # will arrive and the transfer can be parallelized.
  #
  # With slow disks and fast (large bandwidth) networks, diskless replication
  # works better.
  repl-diskless-sync no
  
  # When diskless replication is enabled, it is possible to configure the delay
  # the server waits in order to spawn the child that transfers the RDB via socket
  # to the replicas.
  #
  # This is important since once the transfer starts, it is not possible to serve
  # new replicas arriving, that will be queued for the next RDB transfer, so the server
  # waits a delay in order to let more replicas arrive.
  #
  # The delay is specified in seconds, and by default is 5 seconds. To disable
  # it entirely just set it to 0 seconds and the transfer will start ASAP.
  repl-diskless-sync-delay 5
  
  # Replicas send PINGs to server in a predefined interval. It's possible to change
  # this interval with the repl_ping_replica_period option. The default value is 10
  # seconds.
  #
  # repl-ping-replica-period 10
  
  # The following option sets the replication timeout for:
  #
  # 1) Bulk transfer I/O during SYNC, from the point of view of replica.
  # 2) Master timeout from the point of view of replicas (data, pings).
  # 3) Replica timeout from the point of view of masters (REPLCONF ACK pings).
  #
  # It is important to make sure that this value is greater than the value
  # specified for repl-ping-replica-period otherwise a timeout will be detected
  # every time there is low traffic between the master and the replica.
  #
  # repl-timeout 60
  
  # Disable TCP_NODELAY on the replica socket after SYNC?
  #
  # If you select "yes" Redis will use a smaller number of TCP packets and
  # less bandwidth to send data to replicas. But this can add a delay for
  # the data to appear on the replica side, up to 40 milliseconds with
  # Linux kernels using a default configuration.
  #
  # If you select "no" the delay for data to appear on the replica side will
  # be reduced but more bandwidth will be used for replication.
  #
  # By default we optimize for low latency, but in very high traffic conditions
  # or when the master and replicas are many hops away, turning this to "yes" may
  # be a good idea.
  repl-disable-tcp-nodelay no
  
  # Set the replication backlog size. The backlog is a buffer that accumulates
  # replica data when replicas are disconnected for some time, so that when a replica
  # wants to reconnect again, often a full resync is not needed, but a partial
  # resync is enough, just passing the portion of data the replica missed while
  # disconnected.
  #
  # The bigger the replication backlog, the longer the time the replica can be
  # disconnected and later be able to perform a partial resynchronization.
  #
  # The backlog is only allocated once there is at least a replica connected.
  #
  # repl-backlog-size 1mb
  
  # After a master has no longer connected replicas for some time, the backlog
  # will be freed. The following option configures the amount of seconds that
  # need to elapse, starting from the time the last replica disconnected, for
  # the backlog buffer to be freed.
  #
  # Note that replicas never free the backlog for timeout, since they may be
  # promoted to masters later, and should be able to correctly "partially
  # resynchronize" with the replicas: hence they should always accumulate backlog.
  #
  # A value of 0 means to never release the backlog.
  #
  # repl-backlog-ttl 3600
  
  # The replica priority is an integer number published by Redis in the INFO output.
  # It is used by Redis Sentinel in order to select a replica to promote into a
  # master if the master is no longer working correctly.
  #
  # A replica with a low priority number is considered better for promotion, so
  # for instance if there are three replicas with priority 10, 100, 25 Sentinel will
  # pick the one with priority 10, that is the lowest.
  #
  # However a special priority of 0 marks the replica as not able to perform the
  # role of master, so a replica with priority of 0 will never be selected by
  # Redis Sentinel for promotion.
  #
  # By default the priority is 100.
  replica-priority 100
  
  # It is possible for a master to stop accepting writes if there are less than
  # N replicas connected, having a lag less or equal than M seconds.
  #
  # The N replicas need to be in "online" state.
  #
  # The lag in seconds, that must be <= the specified value, is calculated from
  # the last ping received from the replica, that is usually sent every second.
  #
  # This option does not GUARANTEE that N replicas will accept the write, but
  # will limit the window of exposure for lost writes in case not enough replicas
  # are available, to the specified number of seconds.
  #
  # For example to require at least 3 replicas with a lag <= 10 seconds use:
  #
  # min-replicas-to-write 3
  # min-replicas-max-lag 10
  #
  # Setting one or the other to 0 disables the feature.
  #
  # By default min-replicas-to-write is set to 0 (feature disabled) and
  # min-replicas-max-lag is set to 10.
  
  # A Redis master is able to list the address and port of the attached
  # replicas in different ways. For example the "INFO replication" section
  # offers this information, which is used, among other tools, by
  # Redis Sentinel in order to discover replica instances.
  # Another place where this info is available is in the output of the
  # "ROLE" command of a master.
  #
  # The listed IP and address normally reported by a replica is obtained
  # in the following way:
  #
  #   IP: The address is auto detected by checking the peer address
  #   of the socket used by the replica to connect with the master.
  #
  #   Port: The port is communicated by the replica during the replication
  #   handshake, and is normally the port that the replica is using to
  #   listen for connections.
  #
  # However when port forwarding or Network Address Translation (NAT) is
  # used, the replica may be actually reachable via different IP and port
  # pairs. The following two options can be used by a replica in order to
  # report to its master a specific set of IP and port, so that both INFO
  # and ROLE will report those values.
  #
  # There is no need to use both the options if you need to override just
  # the port or the IP address.
  #
  # replica-announce-ip 5.5.5.5
  # replica-announce-port 1234
  
  ################################## SECURITY ###################################
  
  # Require clients to issue AUTH <PASSWORD> before processing any other
  # commands.  This might be useful in environments in which you do not trust
  # others with access to the host running redis-server.
  #
  # This should stay commented out for backward compatibility and because most
  # people do not need auth (e.g. they run their own servers).
  #
  # Warning: since Redis is pretty fast an outside user can try up to
  # 150k passwords per second against a good box. This means that you should
  # use a very strong password otherwise it will be very easy to break.
  
  requirepass 12345678
  
  # Command renaming.
  #
  # It is possible to change the name of dangerous commands in a shared
  # environment. For instance the CONFIG command may be renamed into something
  # hard to guess so that it will still be available for internal-use tools
  # but not available for general clients.
  #
  # Example:
  #
  # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
  #
  # It is also possible to completely kill a command by renaming it into
  # an empty string:
  #
  # rename-command CONFIG ""
  #
  # Please note that changing the name of commands that are logged into the
  # AOF file or transmitted to replicas may cause problems.
  
  ################################### CLIENTS ####################################
  
  # Set the max number of connected clients at the same time. By default
  # this limit is set to 10000 clients, however if the Redis server is not
  # able to configure the process file limit to allow for the specified limit
  # the max number of allowed clients is set to the current file limit
  # minus 32 (as Redis reserves a few file descriptors for internal uses).
  #
  # Once the limit is reached Redis will close all the new connections sending
  # an error 'max number of clients reached'.
  #
  # maxclients 10000
  
  ############################## MEMORY MANAGEMENT ################################
  
  # Set a memory usage limit to the specified amount of bytes.
  # When the memory limit is reached Redis will try to remove keys
  # according to the eviction policy selected (see maxmemory-policy).
  #
  # If Redis can't remove keys according to the policy, or if the policy is
  # set to 'noeviction', Redis will start to reply with errors to commands
  # that would use more memory, like SET, LPUSH, and so on, and will continue
  # to reply to read-only commands like GET.
  #
  # This option is usually useful when using Redis as an LRU or LFU cache, or to
  # set a hard memory limit for an instance (using the 'noeviction' policy).
  #
  # WARNING: If you have replicas attached to an instance with maxmemory on,
  # the size of the output buffers needed to feed the replicas are subtracted
  # from the used memory count, so that network problems / resyncs will
  # not trigger a loop where keys are evicted, and in turn the output
  # buffer of replicas is full with DELs of keys evicted triggering the deletion
  # of more keys, and so forth until the database is completely emptied.
  #
  # In short... if you have replicas attached it is suggested that you set a lower
  # limit for maxmemory so that there is some free RAM on the system for replica
  # output buffers (but this is not needed if the policy is 'noeviction').
  #
  # maxmemory <bytes>
  
  # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
  # is reached. You can select among five behaviors:
  #
  # volatile-lru -> Evict using approximated LRU among the keys with an expire set.
  # allkeys-lru -> Evict any key using approximated LRU.
  # volatile-lfu -> Evict using approximated LFU among the keys with an expire set.
  # allkeys-lfu -> Evict any key using approximated LFU.
  # volatile-random -> Remove a random key among the ones with an expire set.
  # allkeys-random -> Remove a random key, any key.
  # volatile-ttl -> Remove the key with the nearest expire time (minor TTL)
  # noeviction -> Don't evict anything, just return an error on write operations.
  #
  # LRU means Least Recently Used
  # LFU means Least Frequently Used
  #
  # Both LRU, LFU and volatile-ttl are implemented using approximated
  # randomized algorithms.
  #
  # Note: with any of the above policies, Redis will return an error on write
  #       operations, when there are no suitable keys for eviction.
  #
  #       At the date of writing these commands are: set setnx setex append
  #       incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
  #       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
  #       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
  #       getset mset msetnx exec sort
  #
  # The default is:
  #
  # maxmemory-policy noeviction
  
  # LRU, LFU and minimal TTL algorithms are not precise algorithms but approximated
  # algorithms (in order to save memory), so you can tune it for speed or
  # accuracy. For default Redis will check five keys and pick the one that was
  # used less recently, you can change the sample size using the following
  # configuration directive.
  #
  # The default of 5 produces good enough results. 10 Approximates very closely
  # true LRU but costs more CPU. 3 is faster but not very accurate.
  #
  # maxmemory-samples 5
  
  # Starting from Redis 5, by default a replica will ignore its maxmemory setting
  # (unless it is promoted to master after a failover or manually). It means
  # that the eviction of keys will be just handled by the master, sending the
  # DEL commands to the replica as keys evict in the master side.
  #
  # This behavior ensures that masters and replicas stay consistent, and is usually
  # what you want, however if your replica is writable, or you want the replica to have
  # a different memory setting, and you are sure all the writes performed to the
  # replica are idempotent, then you may change this default (but be sure to understand
  # what you are doing).
  #
  # Note that since the replica by default does not evict, it may end using more
  # memory than the one set via maxmemory (there are certain buffers that may
  # be larger on the replica, or data structures may sometimes take more memory and so
  # forth). So make sure you monitor your replicas and make sure they have enough
  # memory to never hit a real out-of-memory condition before the master hits
  # the configured maxmemory setting.
  #
  # replica-ignore-maxmemory yes
  
  ############################# LAZY FREEING ####################################
  
  # Redis has two primitives to delete keys. One is called DEL and is a blocking
  # deletion of the object. It means that the server stops processing new commands
  # in order to reclaim all the memory associated with an object in a synchronous
  # way. If the key deleted is associated with a small object, the time needed
  # in order to execute the DEL command is very small and comparable to most other
  # O(1) or O(log_N) commands in Redis. However if the key is associated with an
  # aggregated value containing millions of elements, the server can block for
  # a long time (even seconds) in order to complete the operation.
  #
  # For the above reasons Redis also offers non blocking deletion primitives
  # such as UNLINK (non blocking DEL) and the ASYNC option of FLUSHALL and
  # FLUSHDB commands, in order to reclaim memory in background. Those commands
  # are executed in constant time. Another thread will incrementally free the
  # object in the background as fast as possible.
  #
  # DEL, UNLINK and ASYNC option of FLUSHALL and FLUSHDB are user-controlled.
  # It's up to the design of the application to understand when it is a good
  # idea to use one or the other. However the Redis server sometimes has to
  # delete keys or flush the whole database as a side effect of other operations.
  # Specifically Redis deletes objects independently of a user call in the
  # following scenarios:
  #
  # 1) On eviction, because of the maxmemory and maxmemory policy configurations,
  #    in order to make room for new data, without going over the specified
  #    memory limit.
  # 2) Because of expire: when a key with an associated time to live (see the
  #    EXPIRE command) must be deleted from memory.
  # 3) Because of a side effect of a command that stores data on a key that may
  #    already exist. For example the RENAME command may delete the old key
  #    content when it is replaced with another one. Similarly SUNIONSTORE
  #    or SORT with STORE option may delete existing keys. The SET command
  #    itself removes any old content of the specified key in order to replace
  #    it with the specified string.
  # 4) During replication, when a replica performs a full resynchronization with
  #    its master, the content of the whole database is removed in order to
  #    load the RDB file just transferred.
  #
  # In all the above cases the default is to delete objects in a blocking way,
  # like if DEL was called. However you can configure each case specifically
  # in order to instead release memory in a non-blocking way like if UNLINK
  # was called, using the following configuration directives:
  
  lazyfree-lazy-eviction no
  lazyfree-lazy-expire no
  lazyfree-lazy-server-del no
  replica-lazy-flush no
  
  ############################## APPEND ONLY MODE ###############################
  
  # By default Redis asynchronously dumps the dataset on disk. This mode is
  # good enough in many applications, but an issue with the Redis process or
  # a power outage may result into a few minutes of writes lost (depending on
  # the configured save points).
  #
  # The Append Only File is an alternative persistence mode that provides
  # much better durability. For instance using the default data fsync policy
  # (see later in the config file) Redis can lose just one second of writes in a
  # dramatic event like a server power outage, or a single write if something
  # wrong with the Redis process itself happens, but the operating system is
  # still running correctly.
  #
  # AOF and RDB persistence can be enabled at the same time without problems.
  # If the AOF is enabled on startup Redis will load the AOF, that is the file
  # with the better durability guarantees.
  #
  # Please check http://redis.io/topics/persistence for more information.
  
  appendonly yes
  
  # The name of the append only file (default: "appendonly.aof")
  
  appendfilename "appendonly.aof"
  
  # The fsync() call tells the Operating System to actually write data on disk
  # instead of waiting for more data in the output buffer. Some OS will really flush
  # data on disk, some other OS will just try to do it ASAP.
  #
  # Redis supports three different modes:
  #
  # no: don't fsync, just let the OS flush the data when it wants. Faster.
  # always: fsync after every write to the append only log. Slow, Safest.
  # everysec: fsync only one time every second. Compromise.
  #
  # The default is "everysec", as that's usually the right compromise between
  # speed and data safety. It's up to you to understand if you can relax this to
  # "no" that will let the operating system flush the output buffer when
  # it wants, for better performances (but if you can live with the idea of
  # some data loss consider the default persistence mode that's snapshotting),
  # or on the contrary, use "always" that's very slow but a bit safer than
  # everysec.
  #
  # More details please check the following article:
  # http://antirez.com/post/redis-persistence-demystified.html
  #
  # If unsure, use "everysec".
  
  # appendfsync always
  appendfsync everysec
  # appendfsync no
  
  # When the AOF fsync policy is set to always or everysec, and a background
  # saving process (a background save or AOF log background rewriting) is
  # performing a lot of I/O against the disk, in some Linux configurations
  # Redis may block too long on the fsync() call. Note that there is no fix for
  # this currently, as even performing fsync in a different thread will block
  # our synchronous write(2) call.
  #
  # In order to mitigate this problem it's possible to use the following option
  # that will prevent fsync() from being called in the main process while a
  # BGSAVE or BGREWRITEAOF is in progress.
  #
  # This means that while another child is saving, the durability of Redis is
  # the same as "appendfsync none". In practical terms, this means that it is
  # possible to lose up to 30 seconds of log in the worst scenario (with the
  # default Linux settings).
  #
  # If you have latency problems turn this to "yes". Otherwise leave it as
  # "no" that is the safest pick from the point of view of durability.
  
  no-appendfsync-on-rewrite no
  
  # Automatic rewrite of the append only file.
  # Redis is able to automatically rewrite the log file implicitly calling
  # BGREWRITEAOF when the AOF log size grows by the specified percentage.
  #
  # This is how it works: Redis remembers the size of the AOF file after the
  # latest rewrite (if no rewrite has happened since the restart, the size of
  # the AOF at startup is used).
  #
  # This base size is compared to the current size. If the current size is
  # bigger than the specified percentage, the rewrite is triggered. Also
  # you need to specify a minimal size for the AOF file to be rewritten, this
  # is useful to avoid rewriting the AOF file even if the percentage increase
  # is reached but it is still pretty small.
  #
  # Specify a percentage of zero in order to disable the automatic AOF
  # rewrite feature.
  
  auto-aof-rewrite-percentage 100
  auto-aof-rewrite-min-size 64mb
  
  # An AOF file may be found to be truncated at the end during the Redis
  # startup process, when the AOF data gets loaded back into memory.
  # This may happen when the system where Redis is running
  # crashes, especially when an ext4 filesystem is mounted without the
  # data=ordered option (however this can't happen when Redis itself
  # crashes or aborts but the operating system still works correctly).
  #
  # Redis can either exit with an error when this happens, or load as much
  # data as possible (the default now) and start if the AOF file is found
  # to be truncated at the end. The following option controls this behavior.
  #
  # If aof-load-truncated is set to yes, a truncated AOF file is loaded and
  # the Redis server starts emitting a log to inform the user of the event.
  # Otherwise if the option is set to no, the server aborts with an error
  # and refuses to start. When the option is set to no, the user requires
  # to fix the AOF file using the "redis-check-aof" utility before to restart
  # the server.
  #
  # Note that if the AOF file will be found to be corrupted in the middle
  # the server will still exit with an error. This option only applies when
  # Redis will try to read more data from the AOF file but not enough bytes
  # will be found.
  aof-load-truncated yes
  
  # When rewriting the AOF file, Redis is able to use an RDB preamble in the
  # AOF file for faster rewrites and recoveries. When this option is turned
  # on the rewritten AOF file is composed of two different stanzas:
  #
  #   [RDB file][AOF tail]
  #
  # When loading Redis recognizes that the AOF file starts with the "REDIS"
  # string and loads the prefixed RDB file, and continues loading the AOF
  # tail.
  aof-use-rdb-preamble yes
  
  ################################ LUA SCRIPTING  ###############################
  
  # Max execution time of a Lua script in milliseconds.
  #
  # If the maximum execution time is reached Redis will log that a script is
  # still in execution after the maximum allowed time and will start to
  # reply to queries with an error.
  #
  # When a long running script exceeds the maximum execution time only the
  # SCRIPT KILL and SHUTDOWN NOSAVE commands are available. The first can be
  # used to stop a script that did not yet called write commands. The second
  # is the only way to shut down the server in the case a write command was
  # already issued by the script but the user doesn't want to wait for the natural
  # termination of the script.
  #
  # Set it to 0 or a negative value for unlimited execution without warnings.
  lua-time-limit 5000
  
  ################################ REDIS CLUSTER  ###############################
  
  # Normal Redis instances can't be part of a Redis Cluster; only nodes that are
  # started as cluster nodes can. In order to start a Redis instance as a
  # cluster node enable the cluster support uncommenting the following:
  #
  # cluster-enabled yes
  
  # Every cluster node has a cluster configuration file. This file is not
  # intended to be edited by hand. It is created and updated by Redis nodes.
  # Every Redis Cluster node requires a different cluster configuration file.
  # Make sure that instances running in the same system do not have
  # overlapping cluster configuration file names.
  #
  # cluster-config-file nodes-6379.conf
  
  # Cluster node timeout is the amount of milliseconds a node must be unreachable
  # for it to be considered in failure state.
  # Most other internal time limits are multiple of the node timeout.
  #
  # cluster-node-timeout 15000
  
  # A replica of a failing master will avoid to start a failover if its data
  # looks too old.
  #
  # There is no simple way for a replica to actually have an exact measure of
  # its "data age", so the following two checks are performed:
  #
  # 1) If there are multiple replicas able to failover, they exchange messages
  #    in order to try to give an advantage to the replica with the best
  #    replication offset (more data from the master processed).
  #    Replicas will try to get their rank by offset, and apply to the start
  #    of the failover a delay proportional to their rank.
  #
  # 2) Every single replica computes the time of the last interaction with
  #    its master. This can be the last ping or command received (if the master
  #    is still in the "connected" state), or the time that elapsed since the
  #    disconnection with the master (if the replication link is currently down).
  #    If the last interaction is too old, the replica will not try to failover
  #    at all.
  #
  # The point "2" can be tuned by user. Specifically a replica will not perform
  # the failover if, since the last interaction with the master, the time
  # elapsed is greater than:
  #
  #   (node-timeout * replica-validity-factor) + repl-ping-replica-period
  #
  # So for example if node-timeout is 30 seconds, and the replica-validity-factor
  # is 10, and assuming a default repl-ping-replica-period of 10 seconds, the
  # replica will not try to failover if it was not able to talk with the master
  # for longer than 310 seconds.
  #
  # A large replica-validity-factor may allow replicas with too old data to failover
  # a master, while a too small value may prevent the cluster from being able to
  # elect a replica at all.
  #
  # For maximum availability, it is possible to set the replica-validity-factor
  # to a value of 0, which means, that replicas will always try to failover the
  # master regardless of the last time they interacted with the master.
  # (However they'll always try to apply a delay proportional to their
  # offset rank).
  #
  # Zero is the only value able to guarantee that when all the partitions heal
  # the cluster will always be able to continue.
  #
  # cluster-replica-validity-factor 10
  
  # Cluster replicas are able to migrate to orphaned masters, that are masters
  # that are left without working replicas. This improves the cluster ability
  # to resist to failures as otherwise an orphaned master can't be failed over
  # in case of failure if it has no working replicas.
  #
  # Replicas migrate to orphaned masters only if there are still at least a
  # given number of other working replicas for their old master. This number
  # is the "migration barrier". A migration barrier of 1 means that a replica
  # will migrate only if there is at least 1 other working replica for its master
  # and so forth. It usually reflects the number of replicas you want for every
  # master in your cluster.
  #
  # Default is 1 (replicas migrate only if their masters remain with at least
  # one replica). To disable migration just set it to a very large value.
  # A value of 0 can be set but is useful only for debugging and dangerous
  # in production.
  #
  # cluster-migration-barrier 1
  
  # By default Redis Cluster nodes stop accepting queries if they detect there
  # is at least an hash slot uncovered (no available node is serving it).
  # This way if the cluster is partially down (for example a range of hash slots
  # are no longer covered) all the cluster becomes, eventually, unavailable.
  # It automatically returns available as soon as all the slots are covered again.
  #
  # However sometimes you want the subset of the cluster which is working,
  # to continue to accept queries for the part of the key space that is still
  # covered. In order to do so, just set the cluster-require-full-coverage
  # option to no.
  #
  # cluster-require-full-coverage yes
  
  # This option, when set to yes, prevents replicas from trying to failover its
  # master during master failures. However the master can still perform a
  # manual failover, if forced to do so.
  #
  # This is useful in different scenarios, especially in the case of multiple
  # data center operations, where we want one side to never be promoted if not
  # in the case of a total DC failure.
  #
  # cluster-replica-no-failover no
  
  # In order to setup your cluster make sure to read the documentation
  # available at http://redis.io web site.
  
  ########################## CLUSTER DOCKER/NAT support  ########################
  
  # In certain deployments, Redis Cluster nodes address discovery fails, because
  # addresses are NAT-ted or because ports are forwarded (the typical case is
  # Docker and other containers).
  #
  # In order to make Redis Cluster working in such environments, a static
  # configuration where each node knows its public address is needed. The
  # following two options are used for this scope, and are:
  #
  # * cluster-announce-ip
  # * cluster-announce-port
  # * cluster-announce-bus-port
  #
  # Each instruct the node about its address, client port, and cluster message
  # bus port. The information is then published in the header of the bus packets
  # so that other nodes will be able to correctly map the address of the node
  # publishing the information.
  #
  # If the above options are not used, the normal Redis Cluster auto-detection
  # will be used instead.
  #
  # Note that when remapped, the bus port may not be at the fixed offset of
  # clients port + 10000, so you can specify any port and bus-port depending
  # on how they get remapped. If the bus-port is not set, a fixed offset of
  # 10000 will be used as usually.
  #
  # Example:
  #
  # cluster-announce-ip 10.1.1.5
  # cluster-announce-port 6379
  # cluster-announce-bus-port 6380
  
  ################################## SLOW LOG ###################################
  
  # The Redis Slow Log is a system to log queries that exceeded a specified
  # execution time. The execution time does not include the I/O operations
  # like talking with the client, sending the reply and so forth,
  # but just the time needed to actually execute the command (this is the only
  # stage of command execution where the thread is blocked and can not serve
  # other requests in the meantime).
  #
  # You can configure the slow log with two parameters: one tells Redis
  # what is the execution time, in microseconds, to exceed in order for the
  # command to get logged, and the other parameter is the length of the
  # slow log. When a new command is logged the oldest one is removed from the
  # queue of logged commands.
  
  # The following time is expressed in microseconds, so 1000000 is equivalent
  # to one second. Note that a negative number disables the slow log, while
  # a value of zero forces the logging of every command.
  slowlog-log-slower-than 10000
  
  # There is no limit to this length. Just be aware that it will consume memory.
  # You can reclaim memory used by the slow log with SLOWLOG RESET.
  slowlog-max-len 128
  
  ################################ LATENCY MONITOR ##############################
  
  # The Redis latency monitoring subsystem samples different operations
  # at runtime in order to collect data related to possible sources of
  # latency of a Redis instance.
  #
  # Via the LATENCY command this information is available to the user that can
  # print graphs and obtain reports.
  #
  # The system only logs operations that were performed in a time equal or
  # greater than the amount of milliseconds specified via the
  # latency-monitor-threshold configuration directive. When its value is set
  # to zero, the latency monitor is turned off.
  #
  # By default latency monitoring is disabled since it is mostly not needed
  # if you don't have latency issues, and collecting data has a performance
  # impact, that while very small, can be measured under big load. Latency
  # monitoring can easily be enabled at runtime using the command
  # "CONFIG SET latency-monitor-threshold <milliseconds>" if needed.
  latency-monitor-threshold 0
  
  ############################# EVENT NOTIFICATION ##############################
  
  # Redis can notify Pub/Sub clients about events happening in the key space.
  # This feature is documented at http://redis.io/topics/notifications
  #
  # For instance if keyspace events notification is enabled, and a client
  # performs a DEL operation on key "foo" stored in the Database 0, two
  # messages will be published via Pub/Sub:
  #
  # PUBLISH __keyspace@0__:foo del
  # PUBLISH __keyevent@0__:del foo
  #
  # It is possible to select the events that Redis will notify among a set
  # of classes. Every class is identified by a single character:
  #
  #  K     Keyspace events, published with __keyspace@<db>__ prefix.
  #  E     Keyevent events, published with __keyevent@<db>__ prefix.
  #  g     Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ...
  #  $     String commands
  #  l     List commands
  #  s     Set commands
  #  h     Hash commands
  #  z     Sorted set commands
  #  x     Expired events (events generated every time a key expires)
  #  e     Evicted events (events generated when a key is evicted for maxmemory)
  #  A     Alias for g$lshzxe, so that the "AKE" string means all the events.
  #
  #  The "notify-keyspace-events" takes as argument a string that is composed
  #  of zero or multiple characters. The empty string means that notifications
  #  are disabled.
  #
  #  Example: to enable list and generic events, from the point of view of the
  #           event name, use:
  #
  #  notify-keyspace-events Elg
  #
  #  Example 2: to get the stream of the expired keys subscribing to channel
  #             name __keyevent@0__:expired use:
  #
  #  notify-keyspace-events Ex
  #
  #  By default all notifications are disabled because most users don't need
  #  this feature and the feature has some overhead. Note that if you don't
  #  specify at least one of K or E, no events will be delivered.
  notify-keyspace-events ""
  
  ############################### ADVANCED CONFIG ###############################
  
  # Hashes are encoded using a memory efficient data structure when they have a
  # small number of entries, and the biggest entry does not exceed a given
  # threshold. These thresholds can be configured using the following directives.
  hash-max-ziplist-entries 512
  hash-max-ziplist-value 64
  
  # Lists are also encoded in a special way to save a lot of space.
  # The number of entries allowed per internal list node can be specified
  # as a fixed maximum size or a maximum number of elements.
  # For a fixed maximum size, use -5 through -1, meaning:
  # -5: max size: 64 Kb  <-- not recommended for normal workloads
  # -4: max size: 32 Kb  <-- not recommended
  # -3: max size: 16 Kb  <-- probably not recommended
  # -2: max size: 8 Kb   <-- good
  # -1: max size: 4 Kb   <-- good
  # Positive numbers mean store up to _exactly_ that number of elements
  # per list node.
  # The highest performing option is usually -2 (8 Kb size) or -1 (4 Kb size),
  # but if your use case is unique, adjust the settings as necessary.
  list-max-ziplist-size -2
  
  # Lists may also be compressed.
  # Compress depth is the number of quicklist ziplist nodes from *each* side of
  # the list to *exclude* from compression.  The head and tail of the list
  # are always uncompressed for fast push/pop operations.  Settings are:
  # 0: disable all list compression
  # 1: depth 1 means "don't start compressing until after 1 node into the list,
  #    going from either the head or tail"
  #    So: [head]->node->node->...->node->[tail]
  #    [head], [tail] will always be uncompressed; inner nodes will compress.
  # 2: [head]->[next]->node->node->...->node->[prev]->[tail]
  #    2 here means: don't compress head or head->next or tail->prev or tail,
  #    but compress all nodes between them.
  # 3: [head]->[next]->[next]->node->node->...->node->[prev]->[prev]->[tail]
  # etc.
  list-compress-depth 0
  
  # Sets have a special encoding in just one case: when a set is composed
  # of just strings that happen to be integers in radix 10 in the range
  # of 64 bit signed integers.
  # The following configuration setting sets the limit in the size of the
  # set in order to use this special memory saving encoding.
  set-max-intset-entries 512
  
  # Similarly to hashes and lists, sorted sets are also specially encoded in
  # order to save a lot of space. This encoding is only used when the length and
  # elements of a sorted set are below the following limits:
  zset-max-ziplist-entries 128
  zset-max-ziplist-value 64
  
  # HyperLogLog sparse representation bytes limit. The limit includes the
  # 16 bytes header. When an HyperLogLog using the sparse representation crosses
  # this limit, it is converted into the dense representation.
  #
  # A value greater than 16000 is totally useless, since at that point the
  # dense representation is more memory efficient.
  #
  # The suggested value is ~ 3000 in order to have the benefits of
  # the space efficient encoding without slowing down too much PFADD,
  # which is O(N) with the sparse encoding. The value can be raised to
  # ~ 10000 when CPU is not a concern, but space is, and the data set is
  # composed of many HyperLogLogs with cardinality in the 0 - 15000 range.
  hll-sparse-max-bytes 3000
  
  # Streams macro node max size / items. The stream data structure is a radix
  # tree of big nodes that encode multiple items inside. Using this configuration
  # it is possible to configure how big a single node can be in bytes, and the
  # maximum number of items it may contain before switching to a new node when
  # appending new stream entries. If any of the following settings are set to
  # zero, the limit is ignored, so for instance it is possible to set just a
  # max entires limit by setting max-bytes to 0 and max-entries to the desired
  # value.
  stream-node-max-bytes 4096
  stream-node-max-entries 100
  
  # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
  # order to help rehashing the main Redis hash table (the one mapping top-level
  # keys to values). The hash table implementation Redis uses (see dict.c)
  # performs a lazy rehashing: the more operation you run into a hash table
  # that is rehashing, the more rehashing "steps" are performed, so if the
  # server is idle the rehashing is never complete and some more memory is used
  # by the hash table.
  #
  # The default is to use this millisecond 10 times every second in order to
  # actively rehash the main dictionaries, freeing memory when possible.
  #
  # If unsure:
  # use "activerehashing no" if you have hard latency requirements and it is
  # not a good thing in your environment that Redis can reply from time to time
  # to queries with 2 milliseconds delay.
  #
  # use "activerehashing yes" if you don't have such hard requirements but
  # want to free memory asap when possible.
  activerehashing yes
  
  # The client output buffer limits can be used to force disconnection of clients
  # that are not reading data from the server fast enough for some reason (a
  # common reason is that a Pub/Sub client can't consume messages as fast as the
  # publisher can produce them).
  #
  # The limit can be set differently for the three different classes of clients:
  #
  # normal -> normal clients including MONITOR clients
  # replica  -> replica clients
  # pubsub -> clients subscribed to at least one pubsub channel or pattern
  #
  # The syntax of every client-output-buffer-limit directive is the following:
  #
  # client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
  #
  # A client is immediately disconnected once the hard limit is reached, or if
  # the soft limit is reached and remains reached for the specified number of
  # seconds (continuously).
  # So for instance if the hard limit is 32 megabytes and the soft limit is
  # 16 megabytes / 10 seconds, the client will get disconnected immediately
  # if the size of the output buffers reach 32 megabytes, but will also get
  # disconnected if the client reaches 16 megabytes and continuously overcomes
  # the limit for 10 seconds.
  #
  # By default normal clients are not limited because they don't receive data
  # without asking (in a push way), but just after a request, so only
  # asynchronous clients may create a scenario where data is requested faster
  # than it can read.
  #
  # Instead there is a default limit for pubsub and replica clients, since
  # subscribers and replicas receive data in a push fashion.
  #
  # Both the hard or the soft limit can be disabled by setting them to zero.
  client-output-buffer-limit normal 0 0 0
  client-output-buffer-limit replica 256mb 64mb 60
  client-output-buffer-limit pubsub 32mb 8mb 60
  
  # Client query buffers accumulate new commands. They are limited to a fixed
  # amount by default in order to avoid that a protocol desynchronization (for
  # instance due to a bug in the client) will lead to unbound memory usage in
  # the query buffer. However you can configure it here if you have very special
  # needs, such us huge multi/exec requests or alike.
  #
  # client-query-buffer-limit 1gb
  
  # In the Redis protocol, bulk requests, that are, elements representing single
  # strings, are normally limited ot 512 mb. However you can change this limit
  # here.
  #
  # proto-max-bulk-len 512mb
  
  # Redis calls an internal function to perform many background tasks, like
  # closing connections of clients in timeout, purging expired keys that are
  # never requested, and so forth.
  #
  # Not all tasks are performed with the same frequency, but Redis checks for
  # tasks to perform according to the specified "hz" value.
  #
  # By default "hz" is set to 10. Raising the value will use more CPU when
  # Redis is idle, but at the same time will make Redis more responsive when
  # there are many keys expiring at the same time, and timeouts may be
  # handled with more precision.
  #
  # The range is between 1 and 500, however a value over 100 is usually not
  # a good idea. Most users should use the default of 10 and raise this up to
  # 100 only in environments where very low latency is required.
  hz 10
  
  # Normally it is useful to have an HZ value which is proportional to the
  # number of clients connected. This is useful in order, for instance, to
  # avoid too many clients are processed for each background task invocation
  # in order to avoid latency spikes.
  #
  # Since the default HZ value by default is conservatively set to 10, Redis
  # offers, and enables by default, the ability to use an adaptive HZ value
  # which will temporary raise when there are many connected clients.
  #
  # When dynamic HZ is enabled, the actual configured HZ will be used as
  # as a baseline, but multiples of the configured HZ value will be actually
  # used as needed once more clients are connected. In this way an idle
  # instance will use very little CPU time while a busy instance will be
  # more responsive.
  dynamic-hz yes
  
  # When a child rewrites the AOF file, if the following option is enabled
  # the file will be fsync-ed every 32 MB of data generated. This is useful
  # in order to commit the file to the disk more incrementally and avoid
  # big latency spikes.
  aof-rewrite-incremental-fsync yes
  
  # When redis saves RDB file, if the following option is enabled
  # the file will be fsync-ed every 32 MB of data generated. This is useful
  # in order to commit the file to the disk more incrementally and avoid
  # big latency spikes.
  rdb-save-incremental-fsync yes
  
  # Redis LFU eviction (see maxmemory setting) can be tuned. However it is a good
  # idea to start with the default settings and only change them after investigating
  # how to improve the performances and how the keys LFU change over time, which
  # is possible to inspect via the OBJECT FREQ command.
  #
  # There are two tunable parameters in the Redis LFU implementation: the
  # counter logarithm factor and the counter decay time. It is important to
  # understand what the two parameters mean before changing them.
  #
  # The LFU counter is just 8 bits per key, it's maximum value is 255, so Redis
  # uses a probabilistic increment with logarithmic behavior. Given the value
  # of the old counter, when a key is accessed, the counter is incremented in
  # this way:
  #
  # 1. A random number R between 0 and 1 is extracted.
  # 2. A probability P is calculated as 1/(old_value*lfu_log_factor+1).
  # 3. The counter is incremented only if R < P.
  #
  # The default lfu-log-factor is 10. This is a table of how the frequency
  # counter changes with a different number of accesses with different
  # logarithmic factors:
  #
  # +--------+------------+------------+------------+------------+------------+
  # | factor | 100 hits   | 1000 hits  | 100K hits  | 1M hits    | 10M hits   |
  # +--------+------------+------------+------------+------------+------------+
  # | 0      | 104        | 255        | 255        | 255        | 255        |
  # +--------+------------+------------+------------+------------+------------+
  # | 1      | 18         | 49         | 255        | 255        | 255        |
  # +--------+------------+------------+------------+------------+------------+
  # | 10     | 10         | 18         | 142        | 255        | 255        |
  # +--------+------------+------------+------------+------------+------------+
  # | 100    | 8          | 11         | 49         | 143        | 255        |
  # +--------+------------+------------+------------+------------+------------+
  #
  # NOTE: The above table was obtained by running the following commands:
  #
  #   redis-benchmark -n 1000000 incr foo
  #   redis-cli object freq foo
  #
  # NOTE 2: The counter initial value is 5 in order to give new objects a chance
  # to accumulate hits.
  #
  # The counter decay time is the time, in minutes, that must elapse in order
  # for the key counter to be divided by two (or decremented if it has a value
  # less <= 10).
  #
  # The default value for the lfu-decay-time is 1. A Special value of 0 means to
  # decay the counter every time it happens to be scanned.
  #
  # lfu-log-factor 10
  # lfu-decay-time 1
  
  ########################### ACTIVE DEFRAGMENTATION #######################
  #
  # WARNING THIS FEATURE IS EXPERIMENTAL. However it was stress tested
  # even in production and manually tested by multiple engineers for some
  # time.
  #
  # What is active defragmentation?
  # -------------------------------
  #
  # Active (online) defragmentation allows a Redis server to compact the
  # spaces left between small allocations and deallocations of data in memory,
  # thus allowing to reclaim back memory.
  #
  # Fragmentation is a natural process that happens with every allocator (but
  # less so with Jemalloc, fortunately) and certain workloads. Normally a server
  # restart is needed in order to lower the fragmentation, or at least to flush
  # away all the data and create it again. However thanks to this feature
  # implemented by Oran Agra for Redis 4.0 this process can happen at runtime
  # in an "hot" way, while the server is running.
  #
  # Basically when the fragmentation is over a certain level (see the
  # configuration options below) Redis will start to create new copies of the
  # values in contiguous memory regions by exploiting certain specific Jemalloc
  # features (in order to understand if an allocation is causing fragmentation
  # and to allocate it in a better place), and at the same time, will release the
  # old copies of the data. This process, repeated incrementally for all the keys
  # will cause the fragmentation to drop back to normal values.
  #
  # Important things to understand:
  #
  # 1. This feature is disabled by default, and only works if you compiled Redis
  #    to use the copy of Jemalloc we ship with the source code of Redis.
  #    This is the default with Linux builds.
  #
  # 2. You never need to enable this feature if you don't have fragmentation
  #    issues.
  #
  # 3. Once you experience fragmentation, you can enable this feature when
  #    needed with the command "CONFIG SET activedefrag yes".
  #
  # The configuration parameters are able to fine tune the behavior of the
  # defragmentation process. If you are not sure about what they mean it is
  # a good idea to leave the defaults untouched.
  
  # Enabled active defragmentation
  # activedefrag yes
  
  # Minimum amount of fragmentation waste to start active defrag
  # active-defrag-ignore-bytes 100mb
  
  # Minimum percentage of fragmentation to start active defrag
  # active-defrag-threshold-lower 10
  
  # Maximum percentage of fragmentation at which we use maximum effort
  # active-defrag-threshold-upper 100
  
  # Minimal effort for defrag in CPU percentage
  # active-defrag-cycle-min 5
  
  # Maximal effort for defrag in CPU percentage
  # active-defrag-cycle-max 75
  
  # Maximum number of set/hash/zset/list fields that will be processed from
  # the main dictionary scan
  # active-defrag-max-scan-fields 1000
  

Redis + Python

version: '3.9'

services:
  redis:
    image: redis
    container_name: redis
    ports:
      - 1234:6379
    restart: always

  python:
    image: python:3.11
    container_name: python
    ports:
      - 8001:80
    command: sh -c 'pip install redis && tail -f /dev/null'
    depends_on:
      - redis
    restart: always

Redis + Python + Appium + Gitlab

version: '3.9'

services:
  redis:
    image: redis
    container_name: redis
    ports:
      - 1234:6379
    restart: always
    networks:
      - my-network

  python:
    image: python:3.11
    container_name: python
    ports:
      - 8001:80
    command: sh -c 'pip install redis && tail -f /dev/null'
    depends_on:
      - redis
    restart: always
    networks:
      - my-network

  gitlab:
    image: gitlab/gitlab-ce
    container_name: gitlab
    ports:
      - 8081:80
    restart: always
    networks:
      - my-network

  appium:
    image: appium/appium
    container_name: appium
    ports:
      - 4723:4723
    restart: always
    networks:
      - my-network

networks:
  my-network:
    driver: bridge

docker compose + Dockerfile 綜合應用

出處:https://medium.com/%E7%A8%8B%E5%BC%8F%E4%B9%BE%E8%B2%A8/docker-docker-compose-dockerfile-%E7%B6%9C%E5%90%88%E6%87%89%E7%94%A8-7e71ff371ebc

先來講講使用場景吧

舉個簡單的例子：假設我需要一個可以運行 python 的環境、還有一個 redis server 的環境，我要執行 python script 在 redis 上做一些資料儲存與運算。我一開始可能會這樣子啟動、seperate-compose.yml會這樣寫：

兩個容器，彼此用網路連接

seperate-compose.yml

version: '3.5'
services:
  python:
    image: python:3.9-slim
    container_name: py-env
    restart: always
    ports:
      - 8001:80
    command: sh -c 'pip install redis && tail -f /dev/null'
    links:
      - redis # 連結到 redis，讓兩個 container 可以互通網路
  redis:
    image: redis:6-alpine3.15
    restart: always
    container_name: redis
    ports:
      - 127.0.0.1:6379:6379

用指令

docker compose -f seperate-compose.yml up -d

來啟動之後，就可以啟動兩個 container(py-env, redis)

成功啟動 py-env, redis 兩個容器

接著進去剛啟動的 py-env 容器，bash 啟動 python環境連看看 redis，成功在redis這個container中塞入一筆資料(Key: “test”, Value: 1)。來敲指令吧～

$ docker exec -it py-env sh #先進入 py-env 並啟動 shell
# python3 #在容器裡運行python
>>> import redis #載入redis套件
>>> r = redis.Redis(host='redis', port=6379) #連進容器的redis
>>> r.set("test", 1) #塞一筆資料看看
True #代表塞入成功！
>>> exit() #退出python
# exit #退出container

接著來 redis 這個容器看一下資料情形吧～一樣敲指令～

$ docker exec -it redis sh
# redis-cli #進入redis client端
127.0.0.1:6379> get test #獲取剛剛的key值: test
"1" # 成功返回Value
127.0.0.1:6379>

分別進入 py-env, redis 這兩個容器測試資料

BUT…我想要換個做法

這樣我每次都要啟動 py-env, redis這兩個 container 互連才能夠把服務建立起來，我能不能一次到位？只啟動一個 container 就好呢？

i.e 我想要一個 container 同時擁有 python 與 redis 的服務！

一個容器兩種享受，我全都要 🤤

眼尖的讀者可發現在前面的seperate-compose.yml ，其實兩個容器的基底image分別是 python:3.9-slim 與 redis:6-alpine3.15 ，那要在哪裡找一個基底image、是在 build 的時候同時擁有 python+redis的環境呢？

答案就在一開始，我要自己寫一個 Dockerfile 定義好 image。接著再利用 docker compose 把這個強大的 image 啟動成 container💪

先來看看 Dockerfile吧

首先，用下面這個 Dockerfile 建立起 image，簡單敘述一下裡頭做了些什麼事情：

# 1. 抓取基底image: redis
FROM redis:6-alpine3.15 

# 2. 基於redis image, 開始安裝 python 相關環境與套件
RUN apk add --update --no-cache python3 && ln -sf python3 /usr/bin/python
RUN python3 -m ensurepip
RUN pip3 install --no-cache --upgrade pip setuptools
RUN pip install --no-cache-dir redis

再來就是 docker compose 的 yml 檔

重頭戲來撰寫 combine-compose.yml

# docker compose -f redis-compose.yml up -d
version: "3"

services:
  redis:
    build:
      dockerfile: Dockerfile #基於Dockerfile建立image
    restart: always
    container_name: redis #容器名稱
    ports:
      - 6379:6379
    command: sh -c "redis-server --daemonize yes && tail -f /dev/null" #啟動 redis-server

接著執行 docker compose -f combine-compose.yml up -d 來啟動 container

只剩下一個 redis 容器，還擁有 python 環境喔 🥳

接下來進去 redis 這個 container 玩玩看吧

1. 進入容器並啟動shell

   $ docker exec -it redis sh
   

2. 啟動python並嘗試在redis中塞入一筆資料，再退出python

   # python3
   >>> import redis
   >>> r = redis.Redis(host='redis', port=6379)
   >>> r.set("test_comb", 1)
   True
   >>> exit()
   

3. 去redis-server看看資料有沒有成功塞入

   /data# redis-cli
   127.0.0.1:6379> get test_comb
   "1"
   

你有發現嗎？所有動作都在 redis 這個容器裡完成

如此一氣呵成～都在同一個容器內完成🥴

總結

核心概念就是先建立 image，才能啟動 container。建立 image 的方式可以用現成的 docker pull、或是自己寫 Dockerfile 建立; 啟動 container 的方式可以用一般 docker run 指令、或是本文中 docker compose 的方式一次啟動多個。只要掌握住了，萬變不離其宗😎

以上程式碼都放在 github 上了，有興趣的讀者可以抓下來玩玩看

延伸閱讀

以現今的趨勢，其實還是以啟動多容器來架構整個服務比較常見。我會有這種搞怪的做法，單純是因為我想要在 redis 啟動時可以 config 做一些特殊設定，例如：在每天的半夜12點reset鍵值、或是每隔1小時新增一個鍵值。

這些需求沒有辦法用 redis 本身提供的指令做到，所以我只能另外啟動一個 python 環境運行 python script，來做 redis config 特殊設定。

當然可能還是有redis本身支援的方式，就有勞各位大神如果有更好的做法，還請不吝告知小弟，大家互相學習增長：）

#up：啟動 Docker 組合。
#down：停止 Docker 組合。
#logs：顯示 Docker 組合的日誌。
#redis-cli：啟動 Redis 容器的 CLI。
#build：編譯映像。
REDIS_COMPOSE = combine-compose.yml
REDIS_CONTAINER = redis
IMAGE_NAME = redis-python

.PHONY: up down logs redis-cli exec build

up:
	@docker-compose -f $(REDIS_COMPOSE) up -d

down:
	@docker-compose -f $(REDIS_COMPOSE) down

logs:
	@docker-compose -f $(REDIS_COMPOSE) logs -f

redis-cli:
	@docker exec -it $(REDIS_CONTAINER) redis-cli

exec:
	@docker exec -it $(REDIS_CONTAINER) /bin/bash

build:
	docker build -t $(IMAGE_NAME) .

FROM redis

RUN apt-get update && apt-get install -y vim redis-server wget build-essential && \
    wget -q http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz && \
    tar xzf ta-lib-0.4.0-src.tar.gz && \
    cd ta-lib/ && \
    ./configure --prefix=/usr && \
    make && \
    make install && \
    cd .. && \
    rm -rf ta-lib ta-lib-0.4.0-src.tar.gz

RUN wget https://repo.anaconda.com/miniconda/Miniconda3-py38_23.1.0-1-Linux-x86_64.sh -O /tmp/miniconda.sh && \
    /bin/bash /tmp/miniconda.sh -b -p /opt/conda && \
    rm /tmp/miniconda.sh

ENV PATH=/opt/conda/bin:$PATH

COPY requirements.txt /tmp/requirements.txt
RUN pip install -r /tmp/requirements.txt && \
    rm /tmp/requirements.txt

RUN mkdir -p /usr/src/app

COPY *.py /usr/src/app

WORKDIR /usr/src/app/

# docker compose -f redis-compose.yml up -d
version: "3"

services:
  redis:
    build:
      dockerfile: Dockerfile #基於Dockerfile建立image
    image: redis-python
    restart: always
    container_name: redis #容器名稱
    ports:
      - 6380:6379
    command: sh -c "redis-server --daemonize yes && tail -f /dev/null" #啟動 redis-server

import redis 

r = redis.Redis(host="localhost", port=6379, db=1)
r.set('foo', 'bar')
print(r.get('foo'))


print ("hello world!")
print ("Welcome to python cron job")

Redash 入門

出處:https://zhuanlan.zhihu.com/p/444590189

• 下載程式碼

git clone https://github.com/getredash/redash.git
cd redash/
git checkout v10.1.0

• 啟動docker服務

在docker-compose.yml 的同級目錄，新建檔案 .env，內容如下：

REDASH_SECRET_KEY=隨機字串1
REDASH_COOKIE_SECRET=隨機字串2
GOOGLE_CLIENT_ID=隨機字串3

不要把這個檔案提交到git中。然後在命令列輸入：

docker-compose up -d

• 安裝node packages

npm install -g yarn

• 建立資料庫

# 建表
docker-compose -f docker-compose.yml run --rm redash create_db

# 建測試資料
docker-compose run --rm postgres psql -h postgres -U postgres -c "create database tests"

• 然後訪問http://127.0.0.1:5000/就可以打開頁面了。

• 常見問題

• • 使用docker-compose up -d啟動時遇到Error response from daemon: OCI runtime create failed: container_linux.go:367: starting container process caused: exec: "/app/bin/docker-entrypoint": permission denied: unknown。

解決：修改宿主機上的檔案權限：

 sudo chmod 755 /bin/docker-entrypoint
 sudo chmod 755 manager.py

• yarn --frozen-lockfile 時出現node版本不滿足。

使用nvm 管理node版本。nvm 簡單使用方法如下：

nvm list
nvm install 12.0.0
nvm use 12.0.0
node -v 
nvm uninstall 12.0.0

• 前端報錯：Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory 。

在執行相關命令但shell中執行如下命令

export NODE_OPTIONS="--max-old-space-size=8192"

增加記憶體：如8192，16384這樣。

• 個人感受

程式碼比較清晰明瞭，但是每次生成可視化圖表都要徒手寫query，和superset相比工作量太大。如果習慣於點點滑鼠就生成chart，我還是推薦superset，包括二次開發，儘管superset的code有些疊床架屋的感覺。

ClickHouse 簡單部署&使用測試

出處:https://zhuanlan.zhihu.com/p/383817560

介紹

ClickHouse 是一個真正的列式資料庫管理系統（DBMS)。在 ClickHouse 中，資料始終是按列儲存的，包括向量（向量或列塊）執行的過程。只要有可能，操作都是基於向量進行分派的，而不是單個的值，這被稱為«向量化查詢執行»，它有利於降低實際的資料處理開銷。

這個想法並不新鮮，其可以追溯到 APL 程式語言及其後代：A +、J、K 和 Q。向量程式設計被大量用於科學資料處理中。即使在關係型資料庫中，這個想法也不是什麼新的東西：比如，向量程式設計也被大量用於 Vectorwise 系統中。

通常有兩種不同的加速查詢處理的方法：向量化查詢執行和執行階段程式碼生成。在後者中，動態地為每一類查詢生成程式碼，消除了間接分派和動態分派。這兩種方法中，並沒有哪一種嚴格地比另一種好。執行階段程式碼生成可以更好地將多個操作融合在一起，從而充分利用 CPU 執行單元和流水線。向量化查詢執行不是特別實用，因為它涉及必須寫到快取並讀回的臨時向量。如果 L2 快取容納不下臨時資料，那麼這將成為一個問題。但向量化查詢執行更容易利用 CPU 的 SIMD 功能。朋友寫的一篇研究論文表明，將兩種方法結合起來是更好的選擇。ClickHouse 使用了向量化查詢執行，同時初步提供了有限的執行階段動態程式碼生成。

瞭解更多詳情...

1.部署 Clickhouse 服務

建立clickhouse 工作目錄

1.1, pull 鏡像

按照官方推薦的鏡像拉取

docker pull yandex/clickhouse-server

1.2，docker-compose 啟動鏡像

version: "3"

services:
  clickhouse-server:
    image: yandex/clickhouse-server:latest
    container_name: clickhouse-server
    hostname: clickhouse-server
    networks:
      - my-network
    ports:
      - 1111:8123
    restart: always


  python-client:
    image: python:3.11
    container_name: python-client
    hostname: python-client
    command: sh -c 'apt-get update && apt-get install -y vim iputils-ping net-tools && pip install lxml loguru line-notify clickhouse_driver rel numpy pandahouse websocket-client && tail -f /dev/null'
    networks:
      - my-network
    restart: always
    volumes:
      - ./python-client:/app

networks:
  my-network:
    driver: bridge

查看運行狀態

http://127.0.0.1:1111/ 會出現OK字樣代表成功

思考：如何修改clickhouse默認組態？資料如何持久化？如何查看日誌？

1.3 更改默認組態，資料持久化，查看日誌

進入容器查看組態

docker exec -it clickhouse-server /bin/bash

clickhouse 默認組態路徑是: /etc/clickhouse-server/

退出容器，複製組態檔案當前工作目錄

docker cp 容器名:/etc/clickhouse-server/config.xml .
docker cp 容器名:/etc/clickhouse-server/uses.xml .

修改docker-compose 組態檔案

volumes: 
  # 默認組態 寫入config.d/users.d 目錄防止更新後檔案丟失
  - ./config.xml:/etc/clickhouse-server/config.d/config.xml:rw
  - ./users.xml:/etc/clickhouse-server/users.xml:rw
  # 運行日誌
  - ./logs:/var/log/clickhouse-server
  # 資料持久
  - ./data:/var/lib/clickhouse:rw

修改後的完整組態如下

docker network ls  // 如果沒 my-network 要create
docker network create my-network

version: "3"

services:
  clickhouse-server:
    image: yandex/clickhouse-server:latest
    container_name: clickhouse-server
    hostname: clickhouse-server
    networks:
      - my-network
    ports:
      - 1111:8123
      - 8888:9000
    restart: always
    volumes: 
      # 默認組態 寫入config.d/users.d 目錄防止更新後檔案丟失
      - ./config.xml:/etc/clickhouse-server/config.d/config.xml:rw
      - ./users.xml:/etc/clickhouse-server/users.xml:rw
      # 運行日誌
      - ./logs:/var/log/clickhouse-server
      # 資料持久
      - ./data:/var/lib/clickhouse:rw


  python-client:
    image: python:3.11
    container_name: python-client
    hostname: python-client
    command: sh -c 'apt-get update && apt-get install -y vim iputils-ping net-tools && pip install lxml loguru line-notify clickhouse_driver rel numpy pandahouse websocket-client && tail -f /dev/null'
    networks:
      - my-network
    volumes:
      - ./python-client:/app

networks:
  my-network:
    driver: bridge

重新啟動服務

docker-compose down && docker-compose up -d

啟動後目錄結構

├── config.xml
├── data
├── docker-compose-final.yml
├── docker-compose.yml
├── log
├── logs
└── users.xml

瀏覽器再次訪問 http://127.0.0.1:1111/ 會出現OK字樣代表成功

查看容器日誌

docker-compose logs -f

進入容器查看服務資料庫

docker exec -it clickhouse-server /bin/bash

root@clickhouse-server:/# clickhouse-client 
ClickHouse client version 22.1.3.7 (official build).
Connecting to localhost:9000 as user default.
Connected to ClickHouse server version 22.1.3 revision 54455.


clickhouse-server :) show databases;

SHOW DATABASES

Query id: aef1df36-bc09-4c33-8821-c669c8a93c2c

┌─name───────────────┐
│ INFORMATION_SCHEMA │
│ default            │
│ information_schema │
│ system             │
└────────────────────┘

4 rows in set. Elapsed: 0.001 sec. 

服務運行正常！

1.4，建立使用者登錄 （後期使用）

查看users.xml檔案

自訂使用者

<halobug>
    <password_sha256_hex>4754fc7e290a9c280d9497b2d76dd854e77f7e1c92476577fdb52ed22afc13e7</password_sha256_hex>
    <networks incl="networks" replace="replace">
        <ip>::/0</ip>
    </networks>
    <profile>default</profile>
    <quota>default</quota>
    <allow_databases>
       <database>tutorial</database>
       <database>CRYPTO</database>
    </allow_databases>
</halobug>

生成密碼（進入容器運行）

PASSWORD=$(base64 < /dev/urandom | head -c8); echo "$PASSWORD"; echo -n "$PASSWORD" | sha256sum | tr -d '-'

FcP5O5HY
8aaa72053341d6fa19bdd150c8e1ff328e2d56444df1c977ac22f88710bac5ae 

黃色標註為自訂使用者，紅色為生成密碼

驗證使用者密碼，重新啟動服務

# 重啟
docker-compose down && docker-compose up -d
# 進入容器
docker exec -it clickhouse-server /bin/bash
# 驗證使用者名稱密碼
clickhouse-client -u halobug -h 127.0.0.1 --password FcP5O5HY  # FcP5O5HY 是出生成來的


# 建立資料庫 tutorial , tutorial 是 users.xml 建立
CREATE DATABASE tutorial;
CREATE DATABASE CRYPTO;

查看驗證結果

成功！到此服務就搭建完成！

登入 python-clinet 測試讀寫 clickhost

docker exec -it python-client /bin/bash

# 測試是否連通
ping clickhouse-server 

import clickhouse_driver
import pandas as pd


connection_settings = {
    'host': 'clickhouse-server',
    'port': '9000',
    'user': 'halobug',
    'password': 'FcP5O5HY'
}

client = clickhouse_driver.Client(**connection_settings)

# 建立新資料庫
client.execute('CREATE DATABASE IF NOT EXISTS CRYPTO')

print(client.execute("SHOW DATABASES"))
client.execute('USE CRYPTO')

# 創建一個簡單的表格
df = pd.DataFrame({'name': ['Alice', 'Bob', 'Charlie'], 'age': [25, 30, 35]})
client.execute('CREATE TABLE IF NOT EXISTS test_table (name String, age Int32) ENGINE = Memory')

# 將資料框寫入表格
client.execute('INSERT INTO test_table VALUES', df.to_dict('records'))

# 讀取表格中的資料
result = client.execute('SELECT * FROM test_table')
print(result)

from line_notify import LineNotify
from loguru import logger
from clickhouse_driver import Client
from multiprocessing import Process, Queue, Pipe
import signal
import multiprocessing
import rel
import numpy as np
import pandahouse as ph
import pandas as pd
import json
import websocket
import datetime as dt
import os
import sys
import traceback
import time


def monitor(monitor_queue, thread_name, ws_client_p, record_p):
    while True:
        try:
            data = monitor_queue.get(timeout=30)
            logger.info(f"{thread_name}, {os.getpid()}, {data[0]}")
        except Exception as e:
            logger.warning(f"{thread_name} monitor queue is empty, {e}")
            LineNotify("KXwzqEGtIp1JEkS5GjqXqRAT0D4BdQQvCNcqOa7ySfz").send(
                f"{thread_name} monitor queue is empty"
            )
            os.kill(ws_client_p.pid, signal.SIGUSR1)


def getErrMsg(e):
    error_class = e.__class__.__name__  # 取得錯誤類型
    detail = e.args[0]  # 取得詳細內容
    cl, exc, tb = sys.exc_info()  # 取得Call Stack
    lastCallStack = traceback.extract_tb(tb)[-1]  # 取得Call Stack的最後一筆資料
    fileName = lastCallStack[0]  # 取得發生的檔案名稱
    lineNum = lastCallStack[1]  # 取得發生的行號
    funcName = lastCallStack[2]  # 取得發生的函數名稱
    errMsg = 'File "{}", line {}, in {}: [{}] {}'.format(
        fileName, lineNum, funcName, error_class, detail
    )
    return errMsg


logger.add(
    f"{__file__}.log", encoding="utf-8", enqueue=True, retention="10 days",
)


class Watcher:
    def __init__(self):
        self.child = os.fork()
        if self.child == 0:
            return
        else:
            self.watch()

    def watch(self):
        try:
            os.wait()
        except KeyboardInterrupt:
            self.kill()
        sys.exit()

    def kill(self):
        try:
            print("kill")
            os.kill(self.child, signal.SIGKILL)
        except OSError:
            pass


class WebSocketClient(multiprocessing.Process):
    def __init__(
        self, thread_name, ws_url, symbol, params, queue, monitor_queue, line_notify
    ):
        multiprocessing.Process.__init__(self)
        self.__thread_name = thread_name
        self.__ws_url = ws_url
        self.__symbol = symbol
        self.__params = params
        self.__queue = queue
        self.__monitor_queue = monitor_queue
        self.__line_notify = line_notify
        self.__ws = websocket.WebSocketApp(
            self.__ws_url,
            on_open=self.on_open,
            on_message=self.on_message,
            on_close=self.on_close,
            on_error=self.on_error,
            # on_cont_message=self.on_cont_message,
            on_ping=self.on_ping,
            on_pong=self.on_pong,
        )
        self.msg_count = 0
        self.reconnecting_flag = False
        signal.signal(signal.SIGUSR1, self.receive_signal)

    def receive_signal(self, signum, stack):
        logger.warning(
            f"Received:, {signum}, {os.getpid()}, reconnecting_flag:{self.reconnecting_flag}"
        )
        # if not self.reconnecting_flag:
        #    self.reconnecting_flag = True
        #    self.reconnecting()
        # thread = threading.Thread(target=self.reconnecting, args=())
        # thread.start()

    def run(self):
        # self.__ws.run_forever()
        try:
            self.__ws.run_forever(ping_interval=0, dispatcher=rel, reconnect=3)
            rel.signal(2, rel.abort)  # Keyboard Interrupt
            rel.dispatch()
        except Exception as e:
            logger.exception(e)
            # os.kill(os.getpid(), signal.SIGUSR1)
            self.reconnecting()

    def on_open(self, ws):
        logger.info(f"on_pong : {self.reconnecting_flag}")
        self.reconnecting_flag = False
        subscribe_message = {
            "method": "SUBSCRIBE",
            "params": [self.__params],
            "id": 1,
        }
        ws.send(json.dumps(subscribe_message))

    def on_message(self, ws, message):
        if self.__queue.full():
            logger.error("queue is full")
            self.__line_notify.send("queue is full")
        else:
            msg = json.loads(message)
            self.__queue.put(msg)
            self.msg_count = self.msg_count + 1

        if self.msg_count % 20 == 0:
            self.__monitor_queue.put([dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")])
            logger.info(
                f"{self.__thread_name} msg_count:{self.msg_count} qsize:{self.__queue.qsize()}"
            )
            self.msg_count = 0

        # print(json.dumps(msg, indent=4, ensure_ascii=False))

    def on_close(self, ws, status_code, message):
        logger.warning(f"on_close {status_code} {message}")
        self.__line_notify.send("on_close " + str(message))
        self.reconnecting()

    def on_error(self, ws, error):
        logger.error(str(error))
        self.__line_notify.send("on_error " + str(error))
        # self.reconnecting()

    def on_cont_message(self, ws, message, flag):
        logger.warning(f"on_cont_message: {message} {flag}")

    def on_ping(self, ws, message):
        logger.info(f"{self.__thread_name} on_ping")
        ws.send(message, websocket.ABNF.OPCODE_PONG)

    def on_pong(self, ws, message):
        logger.info(f"{self.__thread_name} on_pong")
        ws.send(message, websocket.ABNF.OPCODE_PONG)

    def reconnecting(self):
        logger.info(f"{self.__thread_name} {os.uname()[1]} reconnecting")
        # self.__ws.close()
        # thread = threading.Thread(target=self.__ws.close, args=())
        # thread.start()
        # thread.join()

        # self.__ws.my_close()
        # rel.abort()
        # logger.info(f"{self.__thread_name} websocket closed")

        rel.abort()
        self.__ws.run_forever(ping_interval=0, dispatcher=rel, reconnect=3)
        rel.signal(2, rel.abort)
        rel.dispatch()


class Record(multiprocessing.Process):
    def __init__(self, thread_name, ws_client_p, queue, line_notify):
        multiprocessing.Process.__init__(self)
        self.__thread_name = thread_name
        self.__ws_client_p = ws_client_p
        self.__queue = queue
        self.__line_notify = line_notify
        self.__data = []

    def clear_data(self):
        self.__data.clear()

    def create_db_table(self, df, str_database, str_table):
        dtypes_dict = dict(df.dtypes)
        ch_type_convert_dict = {
            np.dtype("datetime64[ns]"): "Datetime64",
            np.dtype("int64"): "Int64",
            np.dtype("float64"): "Float64",
            np.dtype("object"): "String",
            np.dtype("bool"): "Bool",
        }
        create_table_cmd_str = ""
        for x in dtypes_dict:
            type_str = ch_type_convert_dict.get(dtypes_dict[x], None)
            if type_str is None:
                print(f"Undefined type {dtypes_dict[x]}")
            create_table_cmd_str = (
                create_table_cmd_str + f"`{x}` {type_str} DEFAULT 0, "
            )
        # create_table_cmd_str = f"CREATE TABLE IF NOT EXISTS {str_database}.{str_table} ( {create_table_cmd_str[:-2]}) ENGINE = Log"
        create_table_cmd_str = f"CREATE TABLE IF NOT EXISTS {str_database}.{str_table} ({create_table_cmd_str[:-2]}) ENGINE = MergeTree PARTITION BY year_month_day ORDER BY year_month_day SETTINGS index_granularity = 16384"
        client = Client(host="clickhouse-server", port="9000", user="halobug", password="FcP5O5HY")
        client.execute(f"CREATE DATABASE IF NOT EXISTS {str_database};")
        client.execute(create_table_cmd_str)

    def write_orderbook_to_db(self):
        df = None
        try:
            if "e" in self.__data[0].keys() and self.__data[0]["e"] == "depthUpdate":
                df = pd.DataFrame(self.__data)
                if not df.isnull().values.any():
                    df.rename(
                        columns={"E": "timestamp", "a": "asks", "b": "bids"},
                        inplace=True,
                    )
                    df["date"] = [
                        dt.datetime.fromtimestamp(x / 1000.0) for x in df["timestamp"]
                    ]
                    df["year_month_day"] = [
                        dt.datetime.fromtimestamp(x / 1000.0).strftime("%Y-%m-%d")
                        for x in df["timestamp"]
                    ]
                    df.rename(columns={"s": "pair"}, inplace=True)
                    # 僅保留需要的列
                    df = df[["pair", "asks", "bids", "date", "year_month_day"]]

                    db_name = "CRYPTO"
                    table_name = "BinanceOrderbookPartition_simplifiedFields"
                    connection_info = dict(
                        database=db_name,
                        host="http://clickhouse-server:8123/",
                        user="halobug",
                        password="FcP5O5HY",
                    )

                    self.create_db_table(df, db_name, table_name)
                    ph.to_clickhouse(
                        df,
                        table_name,
                        index=False,
                        chunksize=100000,
                        connection=connection_info,
                    )
                print(df)

            if (
                "event" in self.__data[0].keys()
                and self.__data[0]["event"] == "ORDER_BOOK"
            ):
                df = pd.DataFrame(self.__data)
                if not df.isnull().values.any():
                    df["date"] = [
                        dt.datetime.fromtimestamp(x / 1000.0).strftime(
                            "%Y-%m-%d %H:%M:%S.%f"
                        )
                        for x in df["timestamp"]
                    ]
                    df["year_month_day"] = [
                        dt.datetime.fromtimestamp(x / 1000.0).strftime("%Y-%m-%d")
                        for x in df["timestamp"]
                    ]

                    df = df[["pair", "asks", "bids", "date", "year_month_day"]]
                    db_name = "CRYPTO"
                    table_name = "BitoProOrderbookPartition_simplifiedFields"
                    connection_info = dict(
                        database=db_name,
                        host="http://clickhouse-server:8123/",
                        user="halobug",
                        password="FcP5O5HY",
                    )

                    self.create_db_table(df, db_name, table_name)
                    ph.to_clickhouse(
                        df,
                        table_name,
                        index=False,
                        chunksize=100000,
                        connection=connection_info,
                    )
                print(df)
            self.__data.clear()
        except Exception as e:
            logger.error(df)
            self.__data.clear()
            self.__line_notify.send(getErrMsg(e))
            logger.exception(e)
            os.kill(self.__ws_client_p.pid, signal.SIGUSR1)

    def run(self):
        while True:
            try:
                msg = self.__queue.get(block=True)
                self.__data.append(msg)
                if len(self.__data) > 100:
                    self.write_orderbook_to_db()
            except Exception as e:
                self.__line_notify.send(getErrMsg(e))
                logger.exception(e)


class Manager(multiprocessing.Process):
    def __init__(self, thread_name, ws_url, symbol, params, queue, line_token):
        # threading.Thread.__init__(self)
        multiprocessing.Process.__init__(self)
        self.__thread_name = thread_name
        self.__ws_url = ws_url
        self.__symbol = symbol
        self.__params = params
        self.__queue = queue
        self.__line_notify = LineNotify(line_token)

    def run(self):
        self.__line_notify.send(f"thread_name:{self.__thread_name}")
        monitor_queue = Queue(100)
        ws_client_p = WebSocketClient(
            thread_name=self.__thread_name,
            ws_url=self.__ws_url,
            symbol=self.__symbol,
            params=self.__params,
            queue=self.__queue,
            monitor_queue=monitor_queue,
            line_notify=self.__line_notify,
        )
        record_p = Record(
            thread_name=self.__thread_name,
            ws_client_p=ws_client_p,
            queue=self.__queue,
            line_notify=self.__line_notify,
        )
        tasks = [
            ws_client_p,
            record_p,
        ]
        for t in tasks:
            t.start()

        monitor_task = Process(
            target=monitor,
            args=(monitor_queue, self.__thread_name, ws_client_p, record_p),
        )
        monitor_task.start()

        for task in tasks:
            task.join()


if __name__ == "__main__":
    Watcher()
    bitopro_orderbook_queue = Queue(1000)
    binance_orderbook_queue = Queue(1000)
    tasks = [
        Manager(
            thread_name="BitoPro Thread",
            ws_url="wss://stream.bitopro.com:9443/ws/v1/pub/order-books/BTC_USDT:20",
            symbol="",
            params="",
            queue=bitopro_orderbook_queue,
            line_token="KXwzqEGtIp1JEkS5GjqXqRAT0D4BdQQvCNcqOa7ySfz",
        ),
        Manager(
            thread_name="Binance Thread",
            ws_url="wss://stream.binance.com:9443/ws",
            symbol="",
            params="btcusdt@depth@100ms",
            queue=binance_orderbook_queue,
            line_token="KXwzqEGtIp1JEkS5GjqXqRAT0D4BdQQvCNcqOa7ySfz",
        ),
    ]
    for t in tasks:
        t.start()

    for task in tasks:
        task.join()

dbeaver 登入 docker clickhouse

port 1111
halobug
FcP5O5HY

Tutorial for set up clickhouse server

https://github.com/jneo8/clickhouse-setup

• Makefile

run-single-server:
	docker run -d --name clickhouse-server -p 9911:9000 -p 1121:8123 --ulimit nofile=262144:262144 yandex/clickhouse-server

run-single-client:
	docker run -it --rm --link clickhouse-server:clickhouse-server yandex/clickhouse-client  --host clickhouse-server

run-cluster-client-1:
	docker run -it --rm --network="clickhouse-net" --link clickhouse-01:clickhouse-server yandex/clickhouse-client --host clickhouse-server
run-cluster-client-2:
	docker run -it --rm --network="clickhouse-net" --link clickhouse-02:clickhouse-server yandex/clickhouse-client --host clickhouse-server
run-cluster-client-3:
	docker run -it --rm --network="clickhouse-net" --link clickhouse-03:clickhouse-server yandex/clickhouse-client --host clickhouse-server
run-cluster-client-4:
	docker run -it --rm --network="clickhouse-net" --link clickhouse-04:clickhouse-server yandex/clickhouse-client --host clickhouse-server
run-cluster-client-5:
	docker run -it --rm --network="clickhouse-net" --link clickhouse-05:clickhouse-server yandex/clickhouse-client --host clickhouse-server
run-cluster-client-6:
	docker run -it --rm --network="clickhouse-net" --link clickhouse-06:clickhouse-server yandex/clickhouse-client --host clickhouse-server

run-cluster-client-1-auth:
	docker run -it --rm --network="clickhouse-net" --link clickhouse-01:clickhouse-server yandex/clickhouse-client --host clickhouse-server -u user1 --password 123456

exec:
	docker exec -it clickhouse-server /bin/bash

• docker-compose.yml

version: '3'

services:
    clickhouse-zookeeper:
        image: zookeeper
        ports:
            - "2181:2181"
            - "2182:2182"
        container_name: clickhouse-zookeeper
        hostname: clickhouse-zookeeper

    clickhouse-01:
        image: yandex/clickhouse-server
        hostname: clickhouse-01
        container_name: clickhouse-01
        ports:
            - 9001:9000
        volumes:
                - ./config/clickhouse_config.xml:/etc/clickhouse-server/config.xml
                - ./config/clickhouse_metrika.xml:/etc/clickhouse-server/metrika.xml
                - ./config/macros/macros-01.xml:/etc/clickhouse-server/config.d/macros.xml
                - ./config/users.xml:/etc/clickhouse-server/users.xml
                # - ./data/server-01:/var/lib/clickhouse
        ulimits:
            nofile:
                soft: 262144
                hard: 262144
        depends_on:
            - "clickhouse-zookeeper"

    clickhouse-02:
        image: yandex/clickhouse-server
        hostname: clickhouse-02
        container_name: clickhouse-02
        ports:
            - 9002:9000
        volumes:
                - ./config/clickhouse_config.xml:/etc/clickhouse-server/config.xml
                - ./config/clickhouse_metrika.xml:/etc/clickhouse-server/metrika.xml
                - ./config/macros/macros-02.xml:/etc/clickhouse-server/config.d/macros.xml
                - ./config/users.xml:/etc/clickhouse-server/users.xml
                # - ./data/server-02:/var/lib/clickhouse
        ulimits:
            nofile:
                soft: 262144
                hard: 262144
        depends_on:
            - "clickhouse-zookeeper"

    clickhouse-03:
        image: yandex/clickhouse-server
        hostname: clickhouse-03
        container_name: clickhouse-03
        ports:
            - 9003:9000
        volumes:
                - ./config/clickhouse_config.xml:/etc/clickhouse-server/config.xml
                - ./config/clickhouse_metrika.xml:/etc/clickhouse-server/metrika.xml
                - ./config/macros/macros-03.xml:/etc/clickhouse-server/config.d/macros.xml
                - ./config/users.xml:/etc/clickhouse-server/users.xml
                # - ./data/server-03:/var/lib/clickhouse
        ulimits:
            nofile:
                soft: 262144
                hard: 262144
        depends_on:
            - "clickhouse-zookeeper"

    clickhouse-04:
        image: yandex/clickhouse-server
        hostname: clickhouse-04
        container_name: clickhouse-04
        ports:
            - 9004:9000
        volumes:
                - ./config/clickhouse_config.xml:/etc/clickhouse-server/config.xml
                - ./config/clickhouse_metrika.xml:/etc/clickhouse-server/metrika.xml
                - ./config/macros/macros-04.xml:/etc/clickhouse-server/config.d/macros.xml
                - ./config/users.xml:/etc/clickhouse-server/users.xml
                # - ./data/server-04:/var/lib/clickhouse
        ulimits:
            nofile:
                soft: 262144
                hard: 262144
        depends_on:
            - "clickhouse-zookeeper"

    clickhouse-05:
        image: yandex/clickhouse-server
        hostname: clickhouse-05
        container_name: clickhouse-05
        ports:
            - 9005:9000
        volumes:
                - ./config/clickhouse_config.xml:/etc/clickhouse-server/config.xml
                - ./config/clickhouse_metrika.xml:/etc/clickhouse-server/metrika.xml
                - ./config/macros/macros-05.xml:/etc/clickhouse-server/config.d/macros.xml
                - ./config/users.xml:/etc/clickhouse-server/users.xml
                # - ./data/server-05:/var/lib/clickhouse
        ulimits:
            nofile:
                soft: 262144
                hard: 262144
        depends_on:
            - "clickhouse-zookeeper"

    clickhouse-06:
        image: yandex/clickhouse-server
        hostname: clickhouse-06
        container_name: clickhouse-06
        ports:
            - 9006:9000
        volumes:
                - ./config/clickhouse_config.xml:/etc/clickhouse-server/config.xml
                - ./config/clickhouse_metrika.xml:/etc/clickhouse-server/metrika.xml
                - ./config/macros/macros-06.xml:/etc/clickhouse-server/config.d/macros.xml
                - ./config/users.xml:/etc/clickhouse-server/users.xml
                # - ./data/server-06:/var/lib/clickhouse
        ulimits:
            nofile:
                soft: 262144
                hard: 262144
        depends_on:
            - "clickhouse-zookeeper"
networks:
    default:
        external:
            name: clickhouse-net

Host 建立資料庫

import clickhouse_driver
import pandas as pd


connection_settings = {
    'host': 'localhost',
    'port': '9911',
}

client = clickhouse_driver.Client(**connection_settings)

# 建立新資料庫
client.execute('CREATE DATABASE IF NOT EXISTS CRYPTO')

print(client.execute("SHOW DATABASES"))
client.execute('USE CRYPTO')

# 創建一個簡單的表格
df = pd.DataFrame({'name': ['Alice', 'Bob', 'Charlie']*3333, 'age': [25, 30, 35]*3333})
#df = pd.DataFrame({'name': ['Alice', 'Bob', 'Charlie'], 'age': [25, 30, 35]})

client.execute('CREATE TABLE IF NOT EXISTS test_table (name String, age Int32) ENGINE = Memory')
#client.execute('CREATE TABLE IF NOT EXISTS test_table (name String, age Int32) ENGINE = MergeTree PARTITION BY name ORDER BY age')


# 將資料框寫入表格
client.execute('INSERT INTO test_table VALUES', df.to_dict('records'))

# 讀取表格中的資料
result = client.execute('SELECT * FROM test_table')
print(result)

# 刪除表格
# client.execute('DROP TABLE IF EXISTS test_table')

Docker 安裝 python 運行 local python script

# 使用官方的Python 3.10鏡像作為基礎鏡像
FROM python:3.10

# 將當前目錄下的所有文件複製到容器的/app目錄
COPY . /app

# 設置工作目錄為/app
WORKDIR /app

docker build -t my-python-app .


docker run -v /本地文件的絕對路徑:/app my-python-app python /app/my_script.py
docker run -v /tmp/test_docker:/app my-python-app python my_script.py 

# my_script.py 
print('hello')

使用Docker部署Redpanda

docker pull vectorized/redpanda
docker run -d --name redpanda-node -p 9092:9092 -p 9644:9644 vectorized/redpanda

https://github.com/redpanda-data/redpanda/

from confluent_kafka import Producer, Consumer

producer = Producer({"bootstrap.servers": "localhost:9092"})
producer.produce("test-topic", key="key", value="hello redpanda!")
producer.flush()


consumer = Consumer(
    {
        "bootstrap.servers": "localhost:9092",
        "group.id": "test-group",
        "auto.offset.reset": "earliest",
    }
)
consumer.subscribe(["test-topic"])


while True:
    msg = consumer.poll(1.0)

    if msg is None:
        continue

    if msg.error():
        print(f"Consumer error: {msg.error()}")
        continue

    print(f"Received message: {msg.value().decode('utf-8')}")

consumer.close()

使用 Docker 運行最新版本 GCC 的完整指南

方法一：使用官方 GCC Docker 映像檔（推薦）

1. 建立 Dockerfile

# 使用最新版本的 GCC 官方映像檔
FROM gcc:15

# 設置工作目錄
WORKDIR /app

# 更新套件管理器並安裝必要工具
RUN apt-get update && apt-get install -y \
    vim \
    nano \
    gdb \
    make \
    cmake \
    && rm -rf /var/lib/apt/lists/*

# 建立程式碼目錄
RUN mkdir -p /app/src

# 設置環境變數
ENV CC=gcc
ENV CXX=g++

# 預設命令
CMD ["bash"]

2. 建立測試程式

建立一個簡單的 C++ 程式來測試：

hello.cpp

#include <iostream>
#include <vector>
#include <string>

int main() {
    std::vector<std::string> messages = {
        "Hello from GCC 15!",
        "C++17 is the default standard",
        "Docker + GCC = 🚀"
    };
    
    for (const auto& msg : messages) {
        std::cout << msg << std::endl;
    }
    
    // 顯示 GCC 版本
    std::cout << "\nCompiled with GCC version: " << __VERSION__ << std::endl;
    
    return 0;
}

3. 建立並運行容器

# 建立 Docker 映像檔
docker build -t gcc-dev .

# 運行容器（掛載當前目錄到容器內）
docker run -it -v $(pwd):/app/src gcc-dev

# 或者在 Windows PowerShell 中
docker run -it -v ${PWD}:/app/src gcc-dev

4. 在容器內編譯和運行

# 進入容器後，切換到源碼目錄
cd /app/src

# 編譯 C++ 程式
g++ -std=c++17 -O2 -Wall -Wextra hello.cpp -o hello

# 運行程式
./hello

# 檢查 GCC 版本
gcc --version
g++ --version

方法二：從源碼編譯 GCC 15（進階用法）

1. 進階 Dockerfile

# 使用 Ubuntu 作為基礎映像檔
FROM ubuntu:22.04

# 設置非互動模式
ENV DEBIAN_FRONTEND=noninteractive

# 安裝建構依賴
RUN apt-get update && apt-get install -y \
    build-essential \
    wget \
    curl \
    tar \
    xz-utils \
    libgmp-dev \
    libmpfr-dev \
    libmpc-dev \
    libisl-dev \
    zlib1g-dev \
    && rm -rf /var/lib/apt/lists/*

# 設置工作目錄
WORKDIR /tmp

# 下載並編譯 GCC 15.1
RUN wget https://ftp.gnu.org/gnu/gcc/gcc-15.1.0/gcc-15.1.0.tar.xz \
    && tar -xf gcc-15.1.0.tar.xz \
    && cd gcc-15.1.0 \
    && ./contrib/download_prerequisites \
    && mkdir build \
    && cd build \
    && ../configure \
        --prefix=/usr/local/gcc-15 \
        --enable-languages=c,c++,fortran \
        --disable-multilib \
        --with-system-zlib \
    && make -j$(nproc) \
    && make install \
    && cd / \
    && rm -rf /tmp/gcc-15.1.0*

# 設置環境變數
ENV PATH="/usr/local/gcc-15/bin:${PATH}"
ENV LD_LIBRARY_PATH="/usr/local/gcc-15/lib64:${LD_LIBRARY_PATH}"

# 建立工作目錄
WORKDIR /app

# 預設命令
CMD ["bash"]

方法三：使用 docker-compose（推薦用於開發）

1. 建立 docker-compose.yml

version: '3.8'

services:
  gcc-dev:
    build: .
    container_name: gcc-dev-container
    volumes:
      - .:/app/src
      - gcc-cache:/root/.cache
    working_dir: /app/src
    tty: true
    stdin_open: true
    environment:
      - CC=gcc
      - CXX=g++
      - MAKEFLAGS=-j$(nproc)

volumes:
  gcc-cache:

2. 使用 docker-compose 運行

# 建立並啟動容器
docker-compose up -d

# 進入容器
docker-compose exec gcc-dev bash

# 停止容器
docker-compose down

常用編譯指令

基本編譯

# 編譯 C 程式
gcc -std=c17 -O2 -Wall -Wextra program.c -o program

# 編譯 C++ 程式
g++ -std=c++17 -O2 -Wall -Wextra program.cpp -o program

# 編譯 C++23 程式（實驗性功能）
g++ -std=c++23 -O2 -Wall -Wextra program.cpp -o program

除錯編譯

# 包含除錯資訊
g++ -std=c++17 -g -Wall -Wextra program.cpp -o program

# 使用 GDB 除錯
gdb ./program

效能優化編譯

# 高度優化
g++ -std=c++17 -O3 -march=native -Wall -Wextra program.cpp -o program

# 連結時優化
g++ -std=c++17 -O3 -flto -Wall -Wextra program.cpp -o program

建議的專案結構

my-cpp-project/
├── Dockerfile
├── docker-compose.yml
├── src/
│   ├── main.cpp
│   ├── utils.cpp
│   └── utils.h
├── tests/
│   └── test_main.cpp
├── Makefile
└── README.md

範例 Makefile

CXX = g++
CXXFLAGS = -std=c++17 -O2 -Wall -Wextra
TARGET = app
SRCDIR = src
SOURCES = $(wildcard $(SRCDIR)/*.cpp)
OBJECTS = $(SOURCES:.cpp=.o)

$(TARGET): $(OBJECTS)
	$(CXX) $(OBJECTS) -o $(TARGET)

%.o: %.cpp
	$(CXX) $(CXXFLAGS) -c $< -o $@

clean:
	rm -f $(OBJECTS) $(TARGET)

.PHONY: clean

快速開始腳本

建立一個 start.sh 腳本：

#!/bin/bash

# 建立並運行 GCC 開發環境
echo "正在建立 GCC 開發環境..."
docker build -t gcc-dev .

echo "正在啟動容器..."
docker run -it -v $(pwd):/app/src gcc-dev

echo "環境已準備完成！"

使用方法：

chmod +x start.sh
./start.sh

這樣你就可以在 Docker 容器中使用最新版本的 GCC 15.1 來編譯和運行 C/C++ 程式了！

tools

https://itsfoss.com/rust-cli-tools/

cargo install bottom procs zoxide du-dust exa tealdeer bat difftastic tokei hyperfine fd-find sshx --locked

curl -sS https://raw.githubusercontent.com/ajeetdsouza/zoxide/main/install.sh | bash

~/.bashrc
eval "$(zoxide init bash)"

• A very fast implementation of tldr in Rust: Simplified, example based and community-driven man pages.

tldr strace

• bat

alias cat="bat --theme=\$(defaults read -globalDomain AppleInterfaceStyle &> /dev/null && echo default || echo GitHub)"

• tig

https://github.com/jonas/tig

• pandoc

pandoc -f markdown -t epub3 -o xxx.epub 1.md 2.md 3.m

最直覺的做法是每章自成一個 HTML 檔，作者原來也是這麼做。但起初 Pandoc 將所有 HTML 併成一個 ch001.xhtml (解壓 ePub 觀察到的)，研究發現是因為作者把章標題放在 <h2>，<h1> 放書名，


而 Pandoc 的分檔是以 <h1> 區隔；故我寫了一段 PowerShell 將 h1 移除，h2 改 h1。h3 改 h2，h4 改 h3，修改後 ePub 也修正為一章一個 .html


。但有個已知問題，Pandoc 產生的目錄連結在 Google 電子書閱讀器套件或 Calibre 閱讀時功能正常，點各層章節都能跳到對映位置，但在我的 Kobo Forma 閱讀器上只能跳到章 (.html 層)，無法跳到節 (.html#section-id)。

使用 ls -1 | cut -d " " -f 10- 命令來只列出檔案名稱，忽略 -rw-r--r-- 1 shihyu shihyu 8973 3月 13 20:06 這部分的檔案權限、所有者等詳細資訊，只顯示檔案名稱。 cut -d " " -f 10- 則是使用分割符號 " " （空格）分割每一行，選取第 10 個欄位到最後一個欄位，也就是檔案名稱。

• sed

find . -type f -name "*" -exec sed -i  "s/hello/fuck/g" {} \;

• 更新 git

#!/bin/bash

# Change to the directory containing the Git repositories
cd /path/to/directory

# Find all .git directories and run Git commands on each one
find . -name ".git" -type d -exec sh -c '
  cd "{}" && cd .. && 
  git stash && git pull
' \;

• xelatex

  • XeLaTeX 簡簡單單讓 LaTeX 說中文

  %!TEX encoding = UTF-8 Unicode
  \usepackage{xeCJK}
  %\setCJKmainfont{標楷體}
  %\setCJKmainfont{LiHei Pro}
  \setCJKmainfont{PingFang TC}
  

• 每個月底執行 command

0 0 28-31 * * [ "$(date +\%d -d tomorrow)" = "01" ] && command

• 解壓 zip

 find . -type f -name '*.zip' -exec unzip -d unzip {} \;

asciinema 把終端操作錄製成 gif 動畫

asciinema 是一個開源工具，可以把終端上的操作錄制下來轉換成 git 動畫，也可以進一步使用 ffmpeg 將動畫圖片轉換成 mp4 視頻。

安裝

macOS

brew install asciinema

Shell

Ubuntu/Debian

sudo apt install asciinema

Shell

使用

錄制

asciinema rec demo.cast

Shell

使用 ctrl + d 或 exit 停止錄制

回放

asciinema play demo.cast

Shell

生成 gif 動畫

按照 asciinema 項目的使用建議，錄制好的配置文件可以上傳到官網，然後使用官方的腳本和連接嵌入到自己的網頁。如果需要離線使用，可以通過 asciinema2gif 生成動圖。

asciinema2gif 基於 nodejs 開發，配合 Docker 更簡單。

拉取鏡像

docker pull asciinema/asciicast2gif

Shell

製作 gif

docker run --rm -v $PWD:/data asciinema/asciicast2gif demo.cast demo.gif

Shell

注意 -v $PWD:/data 即宿主機與容器映射存儲的設置，$PWD 代表當前目錄，要確保 demo.cast 文件在當前路徑中。

轉換成 mp4

可以使用 ffmpeg 進一步將 gif 動圖轉換成 mp4 視頻：

ffmpeg -i demo.gif demo.mp4

製作個人專屬看盤軟體

https://medium.com/finmind/%E8%A3%BD%E4%BD%9C%E5%80%8B%E4%BA%BA%E5%B0%88%E5%B1%AC%E7%9C%8B%E7%9B%A4%E8%BB%9F%E9%AB%94-%E4%BA%8C-27081ce44689

首先，將以下專案 clone 下來

https://github.com/FinMind/finmind-visualization

（需要使用 docker 技術，請先確定你安裝了 docker）

1. 建立 docker network：

docker network create finmind_network

2. 建立相關的 services，包含 MySQL 資料庫、RabbitMQ、Redash：

docker-compose -f mysql.yml up -d
docker-compose -f rabbitmq.yml up -d
docker-compose -f redash.yml up -d

3. 建立 FinMind 工具，將使用 FinMind Data 進行視覺化：

如果你有 FinMind Api Token，使用以下指令

FINMIND_API_TOKEN=your_token docker-compose -f finmind.yml up -d

如果沒有 Token，使用以下指令（沒有 token，資料會更新比較慢）

docker-compose -f finmind.yml up -d

邏輯上是，拉 FinMind Data，做視覺化，也就是說，如果是會員，更新資料速度會比較快，如果非會員，資料也是會更新，只是比較慢一點。

4. 建立完成後，以下是相關 services 連線資訊

mysql: http://localhost:8080/
    user : finmind
    password : test
flower: http://localhost:5555/
rabbitmq: http://localhost:15672/
    user : worker
    password : worker
visualization: http://localhost:5000/
finmind-visualization-api: http://localhost:8888/docs

5. 建立 MySQL Table

進入以下連結，http://localhost:8888/docs，

成功後，就會建立相關 Table 了，可以到以下連結查看，http://localhost:8080，帳號密碼是，finmind／test。

6. 拉取歷史資料

目前 MySQL 資料庫都是空的，因此需要拉取 FinMind 資料，方式如下。

一樣進入以下連結，http://localhost:8888/docs，並根據下圖，選擇 dataset，以 TaiwanStockPrice 為例

7. 拉取資料方式

是透過 RabbitMQ 進行，可以使用以下連結進入，http://localhost:15672/，帳號密碼，worker／worker。

等待 queues 消化完成歸 0 後，跳轉到 MySQL，可以看到都已經成功拉取 TaiwanStockPrice 歷史資料了，如下

其他的 Data，也可以用一樣的方式更新歷史資料。

8. 如何定時更新資料？

這時會有讀者想問，如何定時更新資料，首先，跳轉到 scheduler 的 table

預設都是不要定時更新，這部分留給使用者自行決定。

9. 開始建立視覺化

前置工作都準備完成後，資料會定時更新了，開始進入主題，視覺化工具，進入以下連結，http://localhost:5000/，按照下圖步驟，帳號密碼讀者可自行設定

建立 Data Source，與 MySQL 做連結

連線參數

以上成功後，開始建立，第一個 Query

10. 建立第一個 Query

步驟如下圖

輸入以下 SQL

select
  *
from
  TaiwanStockPrice
where
  stock_id = '2330'
  and date >= '2022-01-01'

到這就完成了基本設定，下一篇文章將介紹，如何進行視覺化做圖，如何做出第一篇文章中的圖表。

為函數新增enter和exit級trace

日常開發中，我們為了輔助程序偵錯常常在每個函數的出入口(entry/exit)增加Trace，一般我們多用宏來實現這些Trace語句，例如：

#ifdef XX_DEBUG_
#define TRACE_ENTER() printf("Enter %s\n", __FUNCTION__)
#define TRACE_EXIT() printf("Exit %s\n", __FUNCTION__)
#else
#define TRACE_ENTER()
#define TRACE_EXIT()
#endif

// 有了TRACE_ENTER和TRACE_EXIT後，你就可以在你的函數中使用它們了。例如：
void foo(…)
{
    TRACE_ENTER();
    … …
    TRACE_EXIT();
}

這樣你就可以很容易看到函數的呼叫關係。不過這種手法用起來卻不輕鬆。首先你需要在每個函數中手工加入TRACE_ENTER和TRACE_EXIT，然後再利用XX_DEBUG_宏控制其是否生效。特別是對於初期未新增函數級Enter/Exit Trace的項目，後期加入工作量很大。

另外一種方便的手法：使用GCC的-finstrument-functions選項。-finstrument-functions使得GCC在生成程式碼時自動為每個函數在入口和出口生成__cyg_profile_func_enter和__cyg_profile_func_exit兩個函數呼叫。我們要做的就是給出一份兩個函數的實現即可。最簡單的實現莫過於列印出被呼叫函數的地址了：

/* func_trace.c */
__attribute__((no_instrument_function))
void __cyg_profile_func_enter(void* this_fn, void* call_site)
{
    printf("enter func => %p\n", this_fn);
}

__attribute__((no_instrument_function))
void __cyg_profile_func_exit(void* this_fn, void* call_site)
{
    printf("exit func <= %p\n", this_fn);
}

我們將這兩個函數放入libfunc_trace.so：

gcc -fPIC -shared -o libfunc_trace.so func_trace.c

我們為下面例子新增enter/exit級Trace：

#include <unistd.h>
/* example.c */
static void foo2()
{

}

void foo1()
{
    foo2();
}

void foo()
{
    chdir("/home/tonybai");
    foo1();
}

int main(int argc, const char* argv[])
{
    foo();
    return 0;
}

$ gcc -g example.c -o example -finstrument-functions -no-pie
$ LD_PRELOAD=libfunc_trace.so example
enter func => 0×8048524
enter func => 0x80484e5
enter func => 0x80484b2
enter func => 0×8048484
exit func <= 0×8048484
exit func <= 0x80484b2
exit func <= 0x80484e5
exit func <= 0×8048524

不過只輸出函數地址很難讓人滿意，根據這些地址我們無法得知到底對應的是哪個函數。那我們就嘗試一下將地址轉換為函數名後再輸出，這方面GNU依舊給我們提供了工具，它就是addr2line。addr2line是binutils包中的一個工具，它可以根據提供的地址在可執行檔案中找出對應的函數名、對應的原始碼檔案名稱以及行數。我們改造一下func_trace.c中的兩個函數的實現：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/syscall.h>

#define PATH_MAX 1024
#define gettid() syscall(SYS_gettid)
#define DUMP(func, call) printf("%s: func = %p, called by = %p/n", __FUNCTION__, func, call)

static char path[PATH_MAX];

__attribute__((constructor))
static void executable_path_init()
{
    char    buf[PATH_MAX];

    memset(buf, 0, sizeof(buf));
    memset(path, 0, sizeof(path));

#ifdef _SOLARIS_TRACE
    getcwd(buf, PATH_MAX);
    sprintf(path, "%s/%s", buf, getexecname());
#elif _LINUX_TRACE
    readlink("/proc/self/exe", path, PATH_MAX);
#else
#endif
}

#ifdef __cplusplus
extern "C" {
#endif
__attribute__((no_instrument_function))
void __cyg_profile_func_enter(void* this_fn, void* call_site)
{
    char buf[PATH_MAX];
    char cmd[PATH_MAX];

    memset(buf, 0, sizeof(buf));
    memset(cmd, 0, sizeof(cmd));

    sprintf(cmd, "addr2line %p -e %s -f|head -1", this_fn, path);
    printf("\n%s\n", cmd);

    FILE* ptr = NULL;
    memset(buf, 0, sizeof(buf));

    if ((ptr = popen(cmd, "r")) != NULL) {
        fgets(buf, PATH_MAX, ptr);
        printf("enter func => %p:%s", this_fn, buf);
    }

    (void) pclose(ptr);
}

__attribute__((no_instrument_function))
void __cyg_profile_func_exit(void* this_fn, void* call_site)
{
    char buf[PATH_MAX];
    char cmd[PATH_MAX];

    memset(buf, 0, sizeof(buf));
    memset(cmd, 0, sizeof(cmd));

    sprintf(cmd, "addr2line %p -e %s -f|head -1", this_fn, path);
    printf("\n%s\n", cmd);

    FILE* ptr = NULL;
    memset(buf, 0, sizeof(buf));

    if ((ptr = popen(cmd, "r")) != NULL) {
        fgets(buf, PATH_MAX, ptr);
        printf("exit func <= %p:%s", this_fn, buf);
    }

    (void) pclose(ptr);
}
#ifdef __cplusplus
}
#endif

gcc -D_LINUX_TRACE -fPIC -shared -o libfunc_trace.so func_trace.c
$ gcc -g example.c -o example -finstrument-functions -no-pie 
$ LD_PRELOAD=./libfunc_trace.so ./example
enter func => 0×8048524:main
enter func => 0x80484e5:foo
enter func => 0x80484b2:foo1
enter func => 0×8048484:foo2
exit func <= 0×8048484:foo2
exit func <= 0x80484b2:foo1
exit func <= 0x80484e5:foo
exit func <= 0×8048524:main

關於這個實現，還有幾點要說道說道： 首先libfunc_trace.so是動態連結到你的可執行程序中的，那麼如何獲取addr2line所需要的檔案名稱是一個問題；另外考慮到可執行程序中可能會呼叫chdir這樣的介面更換當前工作路徑，所以我們需要在初始化時就得到可執行檔案的絕對路徑供addr2line使用，否則會出現無法找到可執行檔案的錯誤。在這裡我們利用了GCC的__attribute__擴展： attribute((constructor))

這樣我們就可以在main之前就將可執行檔案的絕對路徑獲取到，並在__cyg_profile_func_enter和__cyg_profile_func_exit中直接引用這個路徑。

在不同平臺下獲取可執行檔案的絕對路徑的方法有不同，像Linux下可以利用"readlink /proc/self/exe"獲得可執行檔案的絕對路徑，而Solaris下則用getcwd和getexecname拼接。

再總結一下，如果你想使用上面的libfunc_trace.so，你需要做的事情有： 1、將編譯好的libfunc_trace.so放在某路徑下，並export LD_PRELOAD=PATH_TO_libfunc_trace.so/libfunc_trace.so 2、你的環境下需要安裝binutils的addr2line 3、你的應用在編譯時增加-finstrument_functions選項。

我已經將這個小工具包放到了Google Code上，有興趣的朋友可以在這裡下載完整原始碼包（20110715更新：支援輸出函數所在原始檔路徑以及所在行號，前提編譯你的程序時務必加上-g選項）

Cmake

常用的 CMake 參數：

1. -DCMAKE_BUILD_TYPE: 用於指定編譯模式，例如 Debug、Release 等。
2. -DCMAKE_INSTALL_PREFIX: 用於指定安裝路徑，預設為 /usr/local。
3. -G: 用於指定生成的專案文件類型，例如 Unix Makefiles、Visual Studio 等。
4. -DCMAKE_C_COMPILER 和 -DCMAKE_CXX_COMPILER: 用於指定 C 和 C++ 編譯器的路徑。
5. -D: 用於定義變數，例如 -DENABLE_FEATURE_A=ON。
6. -DBUILD_SHARED_LIBS: 用於指定是否生成共享庫（動態連結庫），默認為 OFF。
7. -DCMAKE_VERBOSE_MAKEFILE: 用於顯示詳細的編譯信息，包括編譯器命令和編譯時的選項。
8. -DCMAKE_C_FLAGS 和 -DCMAKE_CXX_FLAGS: 用於指定編譯器的選項，例如 -O2、-Wall 等。
9. -DCMAKE_MODULE_PATH: 用於指定 CMake 模組的路徑，例如 /usr/local/share/cmake/Modules。
10. -DCMAKE_PREFIX_PATH: 用於指定查找庫文件和頭文件的路徑，例如 /usr/local/lib 和 /usr/local/include。

以上是一些常用的 CMake 參數，你可以在需要的情況下使用它們來配置你的項目。

在 CMakeLists.txt 中，你可以使用一些指令和變數來配置你的 CMake 項目。以下是一些常用的指令和變數及其解釋：

指令：

1. cmake_minimum_required(VERSION x.y): 指定 CMake 的最低版本需求，例如 cmake_minimum_required(VERSION 3.10)。
2. project(name [LANGUAGES lang1 lang2 ...]): 指定項目的名稱和支持的語言，例如 project(MyProject CXX)。
3. add_executable(name source1 [source2 ...]): 指定生成執行文件的名稱和源文件，例如 add_executable(MyProgram main.cpp)。
4. add_library(name type source1 [source2 ...]): 指定生成靜態庫或動態連結庫的名稱、類型和源文件，例如 add_library(MyLibrary STATIC lib.cpp)。
5. target_link_libraries(target library1 [library2 ...]): 指定目標文件需要連結的庫文件，例如 target_link_libraries(MyProgram MyLibrary)。
6. include_directories(dir1 [dir2 ...]): 指定頭文件搜索路徑，例如 include_directories(include)。

變數：

1. CMAKE_C_COMPILER 和 CMAKE_CXX_COMPILER: 指定 C 和 C++ 編譯器的路徑，例如 set(CMAKE_CXX_COMPILER /usr/bin/g++)。
2. CMAKE_BUILD_TYPE: 指定編譯模式，例如 set(CMAKE_BUILD_TYPE Release)。
3. CMAKE_INSTALL_PREFIX: 指定安裝路徑，例如 set(CMAKE_INSTALL_PREFIX /usr/local)。
4. CMAKE_CXX_FLAGS 和 CMAKE_C_FLAGS: 指定編譯器的選項，例如 set(CMAKE_CXX_FLAGS "-O2 -Wall")。

以上是一些常用的 CMake 指令和變數，你可以在 CMakeLists.txt 文件中使用它們來配置你的項目。

set(CMAKE_BUILD_TYPE DEBUG)
set(CMAKE_C_FLAGS "-O0 -ggdb")
set(CMAKE_C_FLAGS_DEBUG "-O0 -ggdb")
set(CMAKE_C_FLAGS_RELEASE "-O0 -ggdb")
set(CMAKE_CXX_FLAGS "-O0 -ggdb")
set(CMAKE_CXX_FLAGS_DEBUG "-O0 -ggdb")
set(CMAKE_CXX_FLAGS_RELEASE "-O0 -ggdb")

ufw：簡易防火牆設置

出處:https://noob.tw/ufw/

Linux 上的 iptables 可能太難，我們不是專業的資安工程師，也不是什麼 Linux 老鳥。像我們這種菜鳥，還是用 ufw 就好了。這篇整理一些常用的 ufw 設定。

安裝 ufw

ufw 的全名是 Uncomplicated Firewall，意思是不複雜的防火牆。它的指令不但好記，寫好的規則也淺顯易懂，不會像 iptables 的裹腳布又臭又長。

大部分的 Ubuntu 系統應該都已經裝好 ufw。如果你是 Debian，或是什麼特別瘦身版的 Ubuntu 的話，可以透過以下指令安裝：

sudo apt-get install ufw

設定防火牆預設規則

如果你想要規則嚴一點，可以預設封鎖所有通訊埠，再選擇性打開幾個 port；你也可以預設開放所有 port，然後再封鎖幾個 port。預設允許/封鎖的指令如下：

sudo ufw default allow # 預設允許
sudo ufw default deny # 預設封鎖

允許/封鎖通訊埠（port）

如果你要允許 SSH port 的話，可以這樣下：

sudo ufw allow ssh

或是

sudo ufw allow 22

也可以允許或封鎖其他的 port：

sudo ufw allow 80 # 允許 80
sudo ufw allow 443 # 允許 443
sudo ufw deny 3389 # 封鎖 3389
sudo ufw deny 21 # 封鎖 21

甚至可以一次允許一個範圍的 port：

sudo ufw allow 6000:6007/tcp # 允許 TCP 6000~6007
sudo ufw allow 6000:6007/udp # 允許 UDP 6000~6007

來自特定 IP 的規則

上面的規則是針對所有 IP，如果你想要針對某些 IP 可以不受控管，你也可以這樣設定：

sudo ufw allow from 192.168.11.10 # 允許 192.168.11.10 的所有連線
sudo ufw allow from 192.168.11.0/24 # 允許 192.168.11.1~192.168.11.255 的所有連線
sudo ufw deny from 192.168.11.4 # 封鎖 192.168.11.4 的所有連線

如果你只是不想讓某個小明偷偷連到你的 SSH Port，你也可以針對他封鎖：

sudo ufw deny from 192.168.11.7 to any port 22

查看目前設了什麼規則

推薦使用這個指令來看目前設了什麼規則：

sudo ufw status numbered

這個指令會幫你把規則前面加上編號：

Numbered Output:
Status: active

     To                         Action      From
     --                         ------      ----
[ 1] 22                         ALLOW IN    Anywhere
[ 2] 80                         ALLOW IN    Anywhere
[ 3] 443                        ALLOW IN    Anywhere

如果你突然不喜歡某個規則了，可以直接刪除它：

sudo ufw delete 3

那個規則就不見囉！

開啟/關閉/重設防火牆

設定完所有規則後，記得把防火牆打開。

如果你是用 SSH 連線，別忘了要先 allow 自己的 SSH 連線。

sudo ufw enable # 啟用防火牆
sudo ufw disable # 停用防火牆

如果你把規則改爛了，想要重新來過的話，可以重設：

sudo ufw reset

Python 以 PyCryptodome 實作 AES 對稱式加密方法教學與範例

出處：

https://officeguide.cc/python-pycryptodome-aes-symmetric-encryption-tutorial-examples/

以下將介紹如何在 Python 中安裝並使用 PyCryptodome 模組，以 AES 加密方法對資料進行加密與解密。

安裝 PyCryptodome 模組

使用 pip 安裝 Python 的 PyCryptodome 模組：

# 安裝 PyCryptodome 模組
sudo pip3 install pycryptodome

這種安裝方式會讓 PyCryptodome 安裝在 Crypto 套件路徑之下，取代舊的 PyCrypto 模組，這兩個模組會互相干擾，所以不可以同時安裝。

測試 PyCryptodome 模組是否可以正常運作：

# 測試 PyCryptodome 模組
python3 -m Crypto.SelfTest

如果不希望影響到舊的 PyCrypto 模組，也可以選擇以獨立模組的方式安裝，將 PyCryptodome 模組安裝至 Cryptodome 套件路徑之下：

# 安裝 PyCryptodome 模組
sudo pip3 install pycryptodomex

# 測試 PyCryptodome 模組
python -m Cryptodome.SelfTest

產生隨機金鑰

AES 加密方式的區塊長度固定為 128 位元，而金鑰長度則可以是 128、192 或 256 位元，在用 AES 進行資料加密之前，亦須先建立一組金鑰，最簡單的方式就是以隨機的方式產生金鑰。

from Crypto.Random import get_random_bytes

# 產生 256 位元隨機金鑰（32 位元組 = 256 位元）
key = get_random_bytes(32)
print(key)
b'l\n\xe8\x7f#\xec{\xf9\x8a4\xb8hye\xe9V\\\xfb\x01\x08\x854\x89\xc9\xfc\x80\xa2S\x920@}'

以密碼產生金鑰

如果希望使用一般的密碼來對資料進行加密與解密，可以根據密碼與一串固定的 salt 字串，產生對應的金鑰。

首先以亂數方式產生一串隨機的資料作為固定的 salt：

# 產生 salt
print(get_random_bytes(32))
b'\xd0\x18\xa7QM\xd6\x9b\xebxu\xe4\xed\xa8\x83\xf6\xa3/\x01\x9c\x9e\x86n\xda;\x10EdD\xf7\x932\xcc'

為了方便起見，可以將這串 salt 直接寫在程式當中，搭配自己的密碼即可產生金鑰：

from Crypto.Protocol.KDF import PBKDF2

# 固定的 salt
salt = b'\xd0\x18\xa7QM\xd6\x9b\xebxu\xe4\xed\xa8\x83\xf6\xa3/\x01\x9c\x9e\x86n\xda;\x10EdD\xf7\x932\xcc'

# 密碼
password = 'my#password'

# 根據密碼與 salt 產生金鑰
key = PBKDF2(password, salt, dkLen=32)

儲存金鑰

實務上我們通常會將產生的金鑰儲存在檔案中，方便後續的加密與解密使用：

# 金鑰儲存位置
keyPath = "my_key.bin"

# 儲存金鑰
with open(keyPath, "wb") as f:
    f.write(key)

# 讀取金鑰
with open(keyPath, "rb") as f:
    keyFromFile = f.read()

# 檢查金鑰儲存
assert key == keyFromFile, '金鑰不符'

AES CBC 加密模式

以下是使用 AES 的 CBC 模式對資料進行加密的範例，以 CBC 模式加密時需要先對資料進行 padding 處理，再進行加密。

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad

# 輸出的加密檔案名稱
outputFile = 'encrypted.bin'

# 要加密的資料（必須為 bytes）
data = b'My secret data.'

# 以金鑰搭配 CBC 模式建立 cipher 物件
cipher = AES.new(key, AES.MODE_CBC)

# 將輸入資料加上 padding 後進行加密
cipheredData = cipher.encrypt(pad(data, AES.block_size))

# 將初始向量與密文寫入檔案
with open(outputFile, "wb") as f:
    f.write(cipher.iv)
    f.write(cipheredData)

以下則是 CBC 模式的解密方式：

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

# 輸入的加密檔案名稱
inputFile = 'encrypted.bin'

# 從檔案讀取初始向量與密文
with open(inputFile, "rb") as f:
    iv = f.read(16)         # 讀取 16 位元組的初始向量
    cipheredData = f.read() # 讀取其餘的密文

# 以金鑰搭配 CBC 模式與初始向量建立 cipher 物件
cipher = AES.new(key, AES.MODE_CBC, iv=iv)

# 解密後進行 unpadding
originalData = unpad(cipher.decrypt(cipheredData), AES.block_size)

# 輸出解密後的資料
print(originalData)
b'My secret data.'

AES CFB 加密模式

AES 的 CFB 模式跟 CBC 模式很類似，不過資料在加密之前不需要經過 padding 處理。

from Crypto.Cipher import AES

# 輸出的加密檔案名稱
outputFile = 'encrypted.bin'

# 要加密的資料（必須為 bytes）
data = b'My secret data.'

# 以金鑰搭配 CFB 模式建立 cipher 物件
cipher = AES.new(key, AES.MODE_CFB)

# 將輸入資料進行加密
cipheredData = cipher.encrypt(data)

# 將初始向量與密文寫入檔案
with open(outputFile, "wb") as f:
    f.write(cipher.iv)
    f.write(cipheredData)

以下則是 CFB 模式的解密方式：

from Crypto.Cipher import AES

# 輸入的加密檔案名稱
inputFile = 'encrypted.bin'

# 從檔案讀取初始向量與密文
with open(inputFile, "rb") as f:
    iv = f.read(16)         # 讀取 16 位元組的初始向量
    cipheredData = f.read() # 讀取其餘的密文

# 以金鑰搭配 CFB 模式與初始向量建立 cipher 物件
cipher = AES.new(key, AES.MODE_CFB, iv=iv)

# 解密資料
originalData = cipher.decrypt(cipheredData)

# 輸出解密後的資料
print(originalData)
b'My secret data.'

AES EAX 加密模式

AES 的 EAX 加密模式會產生 nonce 與 tag，這兩項必須連同密文一起儲存起來。

from Crypto.Cipher import AES

# 輸出的加密檔案名稱
outputFile = 'encrypted.bin'

# 要加密的資料（必須為 bytes）
data = b'My secret data.'

# 以金鑰搭配 EAX 模式建立 cipher 物件
cipher = AES.new(key, AES.MODE_EAX)

# 將輸入資料進行加密
cipheredData, tag = cipher.encrypt_and_digest(data)

# 將 nonce、tag 與密文寫入檔案
with open(outputFile, "wb") as f:
    f.write(cipher.nonce)
    f.write(tag)
    f.write(cipheredData)

以下則是 EAX 模式的解密方式：

from Crypto.Cipher import AES

# 輸入的加密檔案名稱
inputFile = 'encrypted.bin'

# 從檔案讀取初始向量與密文
with open(inputFile, "rb") as f:
    nonce = f.read(16)      # 讀取 16 位元組的 nonce
    tag = f.read(16)        # 讀取 16 位元組的 tag
    cipheredData = f.read() # 讀取其餘的密文

# 以金鑰搭配 EAX 模式與 nonce 建立 cipher 物件
cipher = AES.new(key, AES.MODE_EAX, nonce)

# 解密並驗證資料
originalData = cipher.decrypt_and_verify(cipheredData, tag)

# 輸出解密後的資料
print(originalData)
b'My secret data.'

Base64 編碼與 JSON 儲存格式

如果要將密文等資料儲存至資料庫或是進行網路傳輸，可以考慮將資料經過 base64 編碼之後，放在一個 JSON 檔案中，以下是一個簡單的範例。

import json
from base64 import b64encode, b64decode

# 要儲存的原始資料
ciphertext = b'...'
iv = b'...'

# 建立字典結構
outputJSON = {
    'ciphertext': b64encode(ciphertext).decode('utf-8'),
    'iv': b64encode(iv).decode('utf-8')
}

# 儲存為 JSON 檔案
with open('encrypted.json', 'w') as f:
    json.dump(outputJSON, f)

# 讀取 JSON 檔案
with open('encrypted.json') as f:
    inputJSON = json.load(f)

# 取用資料
ciphertext = b64decode(inputJSON['ciphertext'].encode('utf-8'))
iv = b64decode(inputJSON['iv'].encode('utf-8'))

參考資料：PyCryptodome、Nitratine、Nitratine

from base64 import b64encode, b64decode
from Crypto.Cipher import AES
from Crypto.Protocol.KDF import PBKDF2
import json


class AESCrypt:
    # 固定的 salt
    salt = b"\xd0\x18\xa7QM\xd6\x9b\xebxu\xe4\xed\xa8\x83\xf6\xa3/\x01\x9c\x9e\x86n\xda;\x10EdD\xf7\x932\xcc"

    def __init__(self, password):
        """
        建立 AESCrypt 實例
        """
        self.password = password
        # 根據密碼與 salt 產生金鑰
        self.key = self.generate_key()

    def generate_key(self):
        """
        根據密碼與 salt 生成 PBKDF2 金鑰
        """
        key = PBKDF2(self.password, AESCrypt.salt, 32)
        return key

    def encrypt(self, data):
        """
        使用 AES 加密資料
        """
        # 建立加密器
        cipher = AES.new(self.key, AES.MODE_CTR)

        # 將資料加密
        ciphertext = cipher.encrypt(data)

        # 回傳加密後的資料與 nonce
        return (b64encode(ciphertext), b64encode(cipher.nonce))

    def decrypt(self, data):
        """
        使用 AES 解密資料
        """
        # 將傳入的資料解析為密文與 nonce
        ciphertext, nonce = b64decode(data[0]), b64decode(data[1])

        # 建立解密器
        cipher = AES.new(self.key, AES.MODE_CTR, nonce=nonce)

        # 解密資料並回傳
        return cipher.decrypt(ciphertext)

if __name__ == "__main__":
    # 創建 AESCrypt 實例
    aes = AESCrypt("my#password")

    # 需要加密的資料
    data = {"id": 12345, "name": "Alice", "age": 30}

    # 編碼為 JSON 格式
    data_json = json.dumps(data)

    # 加密
    encrypted_data = aes.encrypt(data_json.encode("utf-8"))

    # 將加密後的資料寫入文件
    with open("data.dat", "wb") as f:
        f.write(encrypted_data[0])
        f.write(b"\n")
        f.write(encrypted_data[1])

    # 從文件中讀取加密資料
    with open("data.dat", "rb") as f:
        encrypted_data = (f.readline().strip(), f.readline().strip())

    # 解密
    decrypted_data = aes.decrypt(encrypted_data)

    # 將解密後的資料反序列化為 Python 對象
    data_decrypt = json.loads(decrypted_data.decode("utf-8"))
    print(data_decrypt, type(data_decrypt))

PocketBase 完整安裝使用指南

PocketBase 是一個極輕量的後端解決方案，安裝使用非常簡單！

📦 安裝方式

方法 1: 直接下載 (推薦)

# 到官網下載對應系統的執行檔
# https://pocketbase.io/docs/

# Linux/macOS
wget https://github.com/pocketbase/pocketbase/releases/download/v0.22.0/pocketbase_0.22.0_linux_amd64.zip
unzip pocketbase_0.22.0_linux_amd64.zip

# 給執行權限
chmod +x pocketbase

# 啟動
./pocketbase serve

方法 2: 使用 Go 安裝

go install github.com/pocketbase/pocketbase@latest
pocketbase serve

方法 3: Docker

# 使用官方 Docker 映像檔
docker run -d \
  --name pocketbase \
  -p 8090:8090 \
  -v /path/to/pb_data:/pb_data \
  ghcr.io/muchobien/pocketbase:latest

🚀 基本使用

1. 啟動服務

# 基本啟動 (預設 port 8090)
./pocketbase serve

# 自定義端口
./pocketbase serve --http=0.0.0.0:8080

# 啟動時顯示更多資訊
./pocketbase serve --dev

啟動後訪問：

• 管理介面: http://localhost:8090/_/
• API 端點: http://localhost:8090/api/

2. 建立管理員帳號

首次啟動會要求建立管理員帳號，或訪問 http://localhost:8090/_/ 手動建立。

3. 建立 Collection (資料表)

在管理介面中：

1. 點擊 "New collection"
2. 設定 Collection 名稱 (例如: users, posts)
3. 添加欄位 (text, number, email, file 等)
4. 設定權限規則

💻 Python 客戶端使用

安裝 Python SDK

pip install pocketbase

基本操作範例

from pocketbase import PocketBase

# 連接到 PocketBase
client = PocketBase('http://127.0.0.1:8090')

# === 身份驗證 ===

# 管理員登入
admin_data = client.admins.auth_with_password("admin@example.com", "password123")
print("管理員登入成功:", admin_data.token)

# 用戶註冊
user_data = {
    "username": "testuser",
    "email": "test@example.com", 
    "password": "password123",
    "passwordConfirm": "password123"
}

try:
    user = client.collection("users").create(user_data)
    print("用戶註冊成功:", user.id)
except Exception as e:
    print("註冊失敗:", e)

# 用戶登入
try:
    auth_data = client.collection("users").auth_with_password("test@example.com", "password123")
    print("用戶登入成功:", auth_data.token)
except Exception as e:
    print("登入失敗:", e)

CRUD 操作

# 建立資料
def create_post():
    data = {
        "title": "我的第一篇文章",
        "content": "這是文章內容",
        "author": client.auth_store.model.id  # 當前用戶 ID
    }
    
    try:
        record = client.collection("posts").create(data)
        print("建立成功:", record.id)
        return record
    except Exception as e:
        print("建立失敗:", e)
        return None

# 查詢資料
def get_posts():
    try:
        # 查詢所有文章
        records = client.collection("posts").get_full_list()
        print(f"共找到 {len(records)} 篇文章")
        
        for record in records:
            print(f"- {record.title} (ID: {record.id})")
            
        return records
    except Exception as e:
        print("查詢失敗:", e)
        return []

# 根據 ID 查詢單筆資料
def get_post_by_id(post_id):
    try:
        record = client.collection("posts").get_one(post_id)
        print("找到文章:", record.title)
        return record
    except Exception as e:
        print("查詢失敗:", e)
        return None

# 條件查詢
def search_posts(keyword):
    try:
        # 使用過濾器查詢
        filter_query = f'title ~ "{keyword}" || content ~ "{keyword}"'
        records = client.collection("posts").get_full_list(filter=filter_query)
        
        print(f"搜尋 '{keyword}' 找到 {len(records)} 結果")
        return records
    except Exception as e:
        print("搜尋失敗:", e)
        return []

# 更新資料
def update_post(post_id, new_title):
    try:
        data = {"title": new_title}
        record = client.collection("posts").update(post_id, data)
        print("更新成功:", record.title)
        return record
    except Exception as e:
        print("更新失敗:", e)
        return None

# 刪除資料
def delete_post(post_id):
    try:
        client.collection("posts").delete(post_id)
        print("刪除成功")
        return True
    except Exception as e:
        print("刪除失敗:", e)
        return False

檔案上傳

def upload_file():
    try:
        # 上傳檔案到 posts collection
        with open("example.jpg", "rb") as f:
            data = {
                "title": "帶圖片的文章",
                "content": "這篇文章有圖片",
                "image": f  # 直接傳入檔案物件
            }
            
            record = client.collection("posts").create(data)
            print("檔案上傳成功:", record.image)
            
            # 取得檔案 URL
            file_url = client.get_file_url(record, record.image)
            print("檔案連結:", file_url)
            
    except Exception as e:
        print("檔案上傳失敗:", e)

即時訂閱

def setup_realtime():
    def on_record_change(e):
        print("資料異動:", e.action, e.record.id)
        
    # 訂閱 posts collection 的變化
    client.collection("posts").subscribe("*", on_record_change)

🔧 進階設定

環境變數設定

# 設定資料庫路徑
export PB_DATA=/path/to/pb_data

# 設定加密密鑰
export PB_ENCRYPTION_KEY=your-32-char-key

# 啟動
./pocketbase serve

自定義 Hooks (Go)

如果需要自定義邏輯，可以將 PocketBase 作為 Go 框架使用：

package main

import (
    "log"
    "github.com/pocketbase/pocketbase"
    "github.com/pocketbase/pocketbase/core"
)

func main() {
    app := pocketbase.New()

    // 添加自定義 Hook
    app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
        // 自定義邏輯
        return nil
    })

    if err := app.Start(); err != nil {
        log.Fatal(err)
    }
}

🌐 部署到生產環境

Systemd 服務

建立服務檔案：

sudo nano /etc/systemd/system/pocketbase.service

服務設定：

[Unit]
Description=PocketBase
After=network.target

[Service]
Type=simple
User=pocketbase
WorkingDirectory=/opt/pocketbase
ExecStart=/opt/pocketbase/pocketbase serve --http=0.0.0.0:8090
Restart=always

[Install]
WantedBy=multi-user.target

啟用服務：

sudo systemctl enable pocketbase
sudo systemctl start pocketbase

Nginx 反向代理

server {
    listen 80;
    server_name yourdomain.com;
    
    location / {
        proxy_pass http://localhost:8090;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

📁 目錄結構

pb_data/
├── data.db          # SQLite 資料庫
├── logs.db          # 日誌資料庫
└── storage/         # 檔案儲存目錄
    └── collections/

🔍 管理介面功能

• Collections 管理: 建立、編輯資料表結構
• Records 管理: 新增、編輯、刪除資料
• Users 管理: 用戶帳號管理
• Files 管理: 檔案上傳與管理
• Logs 查看: 系統日誌監控
• Settings: 系統設定

🎯 主要優勢

• 極度簡單: 一個檔案就能運行完整的後端服務
• 快速部署: 無需複雜的設定和依賴
• 輕量級: 使用 SQLite，資源消耗低
• 完整功能: 包含認證、資料庫、檔案儲存、即時訂閱
• 開源: 完全開源，可自由修改

📝 適用場景

• 快速原型開發
• 小型專案或個人專案
• 資源有限的環境
• 需要快速上線的 MVP
• 學習和實驗用途

PocketBase 的最大優勢就是極度簡單，非常適合快速開發和部署！

🔬 測試範例

Python 測試腳本

from pocketbase import PocketBase
import requests

client = PocketBase("http://202.182.118.167:8090")


# 方法1: 直接 HTTP 請求測試
def test_auth_endpoints():
    endpoints = [
        "/api/admins/auth-with-password",
    ]

    for endpoint in endpoints:
        url = f"http://202.182.118.167:8090{endpoint}"
        payload = {"identity": "yaoshihyu@gmail.com", "password": "2lraroai2lraroai"}

        try:
            response = requests.post(url, json=payload, timeout=10)
            print(f"Testing {endpoint}:")
            print(f"  Status: {response.status_code}")
            if response.status_code == 200:
                print(f"  Success! Response: {response.json()}")
                return endpoint, response.json()
            else:
                print(f"  Error: {response.text}")
        except Exception as e:
            print(f"  Exception: {e}")

    return None, None


# 測試不同端點
endpoint, auth_data = test_auth_endpoints()

if auth_data:
    print(f"\n成功認證使用端點: {endpoint}")
else:
    print("\n所有端點都失敗了")

    # 方法2: 嘗試使用 PocketBase 客戶端的不同方法
    try:
        # 嘗試作為普通用戶認證
        user_auth = client.collection("users").auth_with_password(
            "xxxxxxxx@gmail.com", "2lxxxxx"
        )
        print("用戶認證成功:", user_auth.token)
    except Exception as e:
        print(f"用戶認證失敗: {e}")

Shell 腳本測試

#!/bin/bash

# 獲取 token
TOKEN=$(curl -s -X POST "http://202.182.118.167:8090/api/admins/auth-with-password" \
  -H "Content-Type: application/json" \
  -d '{"identity":"xxxxxxxxxx@gmail.com","password":"2lxxx"}' | jq -r '.token')

echo "Token: $TOKEN"


echo "=== 所有 Collections ==="
COLLECTIONS=$(curl -s -X GET "http://202.182.118.167:8090/api/collections" \
  -H "Authorization: Bearer $TOKEN")

echo "$COLLECTIONS" | jq '.items[] | {
  name: .name,
  type: .type,
  id: .id,
  created: .created,
  schema_fields: [.schema[] | .name]
}'

# 創建測試用戶
echo "=== 創建用戶 ==="
curl -X POST "http://202.182.118.167:8090/api/collections/users/records" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{
    "username": "john_doe_tt",
    "email": "john.doeTT@example.com",
    "password": "securepass1235",
    "passwordConfirm": "securepass1235",
    "name": "John Doe TT"
  }' | jq '.'

# 查看所有用戶
echo "=== 查看所有用戶 ==="
curl -s -X GET "http://202.182.118.167:8090/api/collections/users/records" \
  -H "Authorization: Bearer $TOKEN" | jq '.'

股票數據操作腳本

#!/bin/bash

# 簡單股票數據腳本
TOKEN="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3NTUwMTA1NzgsImlkIjoiMnloYjhsd2tsZ3k0Zzk0IiwidHlwZSI6ImFkbWluIn0.rPi3xend3dCrHzDIpG86uDwsZ4eGXrNb4SsK8poDaRw"
BASE_URL="http://202.182.118.167:8090"

echo "=== 股票數據操作 ==="

# 1. 創建股票數據集合
echo "1. 創建股票集合..."
curl -X POST "$BASE_URL/api/collections" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{
    "name": "stocks",
    "type": "base",
    "schema": [
      {"name": "symbol", "type": "text", "required": true},
      {"name": "name", "type": "text"},
      {"name": "date", "type": "date", "required": true},
      {"name": "open", "type": "number", "required": true},
      {"name": "high", "type": "number", "required": true},
      {"name": "low", "type": "number", "required": true},
      {"name": "close", "type": "number", "required": true},
      {"name": "volume", "type": "number", "required": true}
    ]
  }' > /dev/null 2>&1

echo "✓ 集合創建完成"

# 2. 寫入股票數據
echo "2. 寫入股票數據..."

# 台積電
curl -s -X POST "$BASE_URL/api/collections/stocks/records" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{
    "symbol": "2330",
    "name": "台積電",
    "date": "2025-07-29",
    "open": 1010.0,
    "high": 1025.0,
    "low": 1005.0,
    "close": 1020.0,
    "volume": 15623000
  }' > /dev/null

# 鴻海
curl -s -X POST "$BASE_URL/api/collections/stocks/records" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{
    "symbol": "2317",
    "name": "鴻海",
    "date": "2025-07-29",
    "open": 120.5,
    "high": 122.0,
    "low": 119.0,
    "close": 121.5,
    "volume": 8945000
  }' > /dev/null

# 聯發科
curl -s -X POST "$BASE_URL/api/collections/stocks/records" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{
    "symbol": "2454",
    "name": "聯發科",
    "date": "2025-07-29",
    "open": 800.0,
    "high": 815.0,
    "low": 795.0,
    "close": 810.0,
    "volume": 3245000
  }' > /dev/null

echo "✓ 股票數據寫入完成"

# 3. 讀取數據
echo "3. 讀取股票數據..."
curl -s "$BASE_URL/api/collections/stocks/records" \
  -H "Authorization: Bearer $TOKEN" | \
  jq '.items[] | {symbol, name, date, open, high, low, close, volume}'

# 4. 導出 CSV
echo "4. 導出 CSV..."
echo "symbol,name,date,open,high,low,close,volume" > stocks.csv
curl -s "$BASE_URL/api/collections/stocks/records" \
  -H "Authorization: Bearer $TOKEN" | \
  jq -r '.items[] | [.symbol, .name, .date, .open, .high, .low, .close, .volume] | @csv' >> stocks.csv

echo "✓ 數據已導出到 stocks.csv"
echo ""
echo "=== 完成 ==="
echo "- 集合已創建"
echo "- 3筆股票數據已寫入"
echo "- 數據已顯示"
echo "- CSV已導出"

#!/bin/bash

# 股票買賣超資料腳本
TOKEN="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3NTUwMTA1NzgsImlkIjoiMnloYjhsd2tsZ3k0Zzk0IiwidHlwZSI6ImFkbWluIn0.rPi3xend3dCrHzDIpG86uDwsZ4eGXrNb4SsK8poDaRw"
BASE_URL="http://202.182.118.167:8090"

echo "=== 股票券商買賣超資料 ==="

# 1. 建立集合
echo "1. 創建集合 broker_trades..."
curl -X POST "$BASE_URL/api/collections" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{
    "name": "broker_trades",
    "type": "base",
    "schema": [
      {"name": "symbol", "type": "text", "required": true},
      {"name": "date", "type": "date", "required": true},
      {"name": "type", "type": "text", "required": true},
      {"name": "broker", "type": "text", "required": true},
      {"name": "volume", "type": "number", "required": true},
      {"name": "avg_buy", "type": "number", "required": true},
      {"name": "avg_sell", "type": "number", "required": true}
    ]
  }' > /dev/null 2>&1
echo "✓ 集合創建完成"

# 資料共用參數
SYMBOL="2330"
DATE="2025-07-29"

# 2. 寫入買超 Top15
echo "2. 寫入買超 Top15..."
declare -a BUYERS=(
"新加坡商瑞銀,1337,1140.32,1140.55"
"美商高盛,1328,1136.23,1133.81"
"美林,1142,1134.32,1134.55"
"富邦-台北,1027,1137.64,1133.18"
"凱基-台北,593,1134.65,1132.22"
"花旗環球,311,1135.53,1137.82"
"港商麥格理,166,1136.74,1136.80"
"永豐金,128,1135.34,1134.11"
"永豐金-中正,61,1135.74,1130.32"
"華南永昌-岡山,58,1134.33,1130.00"
"台中銀,56,1130.10,1132.78"
"凱基-松山,50,1136.30,1134.96"
"第一金-彰化,44,1130.46,1137.09"
"香港上海匯豐,33,1135.15,1135.60"
"元大-天母,33,1132.91,1133.75"
)

for line in "${BUYERS[@]}"; do
  IFS=',' read -r BROKER VOLUME BUY SELL <<< "$line"
  curl -s -X POST "$BASE_URL/api/collections/broker_trades/records" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $TOKEN" \
    -d "{
      \"symbol\": \"$SYMBOL\",
      \"date\": \"$DATE\",
      \"type\": \"buy\",
      \"broker\": \"$BROKER\",
      \"volume\": $VOLUME,
      \"avg_buy\": $BUY,
      \"avg_sell\": $SELL
    }" > /dev/null
done

# 3. 寫入賣超 Top15
echo "3. 寫入賣超 Top15..."
declare -a SELLERS=(
"摩根士丹利,1751,1137.06,1132.54"
"摩根大通,1533,1137.90,1136.03"
"富邦-南京,657,1131.71,1139.32"
"富邦,403,1133.88,1134.93"
"元大,258,1133.46,1134.04"
"大和國泰,238,1130.00,1141.76"
"港商野村,222,1134.49,1136.85"
"國泰,187,1134.92,1134.45"
"元富,113,1133.70,1134.56"
"致和,99,1131.23,1144.90"
"兆豐-三民,96,1138.28,1129.90"
"凱基,88,1137.39,1131.14"
"中國信託,85,1133.87,1131.53"
"第一金,79,1134.46,1130.28"
"第一金-新興,78,1136.50,1130.34"
)

for line in "${SELLERS[@]}"; do
  IFS=',' read -r BROKER VOLUME BUY SELL <<< "$line"
  curl -s -X POST "$BASE_URL/api/collections/broker_trades/records" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $TOKEN" \
    -d "{
      \"symbol\": \"$SYMBOL\",
      \"date\": \"$DATE\",
      \"type\": \"sell\",
      \"broker\": \"$BROKER\",
      \"volume\": $VOLUME,
      \"avg_buy\": $BUY,
      \"avg_sell\": $SELL
    }" > /dev/null
done

echo "✓ 資料寫入完成"

# 4. 讀取資料
echo "4. 顯示資料..."
curl -s "$BASE_URL/api/collections/broker_trades/records" \
  -H "Authorization: Bearer $TOKEN" | \
  jq '.items[] | {symbol, date, type, broker, volume, avg_buy, avg_sell}'

# 5. 匯出CSV
echo "5. 導出 CSV..."
echo "symbol,date,type,broker,volume,avg_buy,avg_sell" > broker_trades.csv
curl -s "$BASE_URL/api/collections/broker_trades/records" \
  -H "Authorization: Bearer $TOKEN" | \
  jq -r '.items[] | [.symbol, .date, .type, .broker, .volume, .avg_buy, .avg_sell] | @csv' >> broker_trades.csv

echo "✓ 資料已導出 broker_trades.csv"
echo ""
echo "=== 完成 ==="

import requests
import csv

# === 設定 ===
TOKEN = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3NTUwMTA1NzgsImlkIjoiMnloYjhsd2tsZ3k0Zzk0IiwidHlwZSI6ImFkbWluIn0.rPi3xend3dCrHzDIpG86uDwsZ4eGXrNb4SsK8poDaRw"

BASE_URL = "http://202.182.118.167:8090"
HEADERS = {"Content-Type": "application/json", "Authorization": f"Bearer {TOKEN}"}

SYMBOL = "2330"
DATE = "2025-07-29"
COLLECTION = "broker_trades"

# === 資料 ===
buyers = [
    ("新加坡商瑞銀", 1337, 1140.32, 1140.55),
    ("美商高盛", 1328, 1136.23, 1133.81),
    ("美林", 1142, 1134.32, 1134.55),
    ("富邦-台北", 1027, 1137.64, 1133.18),
    ("凱基-台北", 593, 1134.65, 1132.22),
    ("花旗環球", 311, 1135.53, 1137.82),
    ("港商麥格理", 166, 1136.74, 1136.80),
    ("永豐金", 128, 1135.34, 1134.11),
    ("永豐金-中正", 61, 1135.74, 1130.32),
    ("華南永昌-岡山", 58, 1134.33, 1130.00),
    ("台中銀", 56, 1130.10, 1132.78),
    ("凱基-松山", 50, 1136.30, 1134.96),
    ("第一金-彰化", 44, 1130.46, 1137.09),
    ("香港上海匯豐", 33, 1135.15, 1135.60),
    ("元大-天母", 33, 1132.91, 1133.75),
]

sellers = [
    ("摩根士丹利", 1751, 1137.06, 1132.54),
    ("摩根大通", 1533, 1137.90, 1136.03),
    ("富邦-南京", 657, 1131.71, 1139.32),
    ("富邦", 403, 1133.88, 1134.93),
    ("元大", 258, 1133.46, 1134.04),
    ("大和國泰", 238, 1130.00, 1141.76),
    ("港商野村", 222, 1134.49, 1136.85),
    ("國泰", 187, 1134.92, 1134.45),
    ("元富", 113, 1133.70, 1134.56),
    ("致和", 99, 1131.23, 1144.90),
    ("兆豐-三民", 96, 1138.28, 1129.90),
    ("凱基", 88, 1137.39, 1131.14),
    ("中國信託", 85, 1133.87, 1131.53),
    ("第一金", 79, 1134.46, 1130.28),
    ("第一金-新興", 78, 1136.50, 1130.34),
]


# === 工具函式 ===


def create_collection():
    print("1. 創建集合...")
    payload = {
        "name": COLLECTION,
        "type": "base",
        "schema": [
            {"name": "symbol", "type": "text", "required": True},
            {"name": "date", "type": "date", "required": True},
            {"name": "type", "type": "text", "required": True},
            {"name": "broker", "type": "text", "required": True},
            {"name": "volume", "type": "number", "required": True},
            {"name": "avg_buy", "type": "number", "required": True},
            {"name": "avg_sell", "type": "number", "required": True},
        ],
    }
    r = requests.post(f"{BASE_URL}/api/collections", headers=HEADERS, json=payload)
    if r.ok:
        print("✓ 集合已創建")
    else:
        print(f"⚠️ 集合創建失敗：{r.status_code} - {r.text}")


def insert_records(records, trade_type):
    for broker, volume, avg_buy, avg_sell in records:
        payload = {
            "symbol": SYMBOL,
            "date": DATE,
            "type": trade_type,
            "broker": broker,
            "volume": volume,
            "avg_buy": avg_buy,
            "avg_sell": avg_sell,
        }
        r = requests.post(
            f"{BASE_URL}/api/collections/{COLLECTION}/records",
            headers=HEADERS,
            json=payload,
        )
        if not r.ok:
            print(f"⚠️ 寫入失敗: {broker} ({trade_type})")


def fetch_all_records():
    res = requests.get(
        f"{BASE_URL}/api/collections/{COLLECTION}/records", headers=HEADERS
    )
    if not res.ok:
        print("⚠️ 讀取資料失敗")
        return []
    return res.json().get("items", [])


def print_records(records):
    print("4. 資料預覽：")
    for item in records:
        print(
            f"{item['date']} [{item['type']}] {item['broker']}: "
            f"{item['volume']} 張 | 買 {item['avg_buy']} 賣 {item['avg_sell']}"
        )


def export_to_csv(records, filename="broker_trades.csv"):
    print(f"5. 匯出 CSV 至 {filename}...")
    with open(filename, "w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerow(
            ["symbol", "date", "type", "broker", "volume", "avg_buy", "avg_sell"]
        )
        for item in records:
            writer.writerow(
                [
                    item["symbol"],
                    item["date"],
                    item["type"],
                    item["broker"],
                    item["volume"],
                    item["avg_buy"],
                    item["avg_sell"],
                ]
            )
    print("✓ 匯出完成")


# === 執行流程 ===
def main():
    create_collection()
    print("2. 寫入買超 Top15...")
    insert_records(buyers, "buy")
    print("3. 寫入賣超 Top15...")
    insert_records(sellers, "sell")
    print("✓ 資料已寫入")

    data = fetch_all_records()
    print_records(data)
    export_to_csv(data)


if __name__ == "__main__":
    main()

🌐 網站變動追蹤工具 - changedetection.io 使用教學（Docker）

📦 安裝步驟

git clone https://github.com/dgtlmoon/changedetection.io.git
cd changedetection.io
docker compose up -d

這會啟動一個本機服務，使用 Docker 建立網站監控後台。

🌍 開啟網站管理介面

打開瀏覽器，輸入：

http://localhost:5000

如果是遠端主機，請改成伺服器的 IP，例如：

http://192.168.1.123:5000

➕ 新增要追蹤的網站

1. 點選右上角 "Add new"

2. 填入網址，例如：

   https://www.ptt.cc/bbs/Gossiping/index.html
   

3. （可選）設定：

   • 比對頻率（預設每 5 分鐘）
   • 通知條件
   • 只追蹤頁面某區塊（使用 CSS Selector）

🔍 查看變更紀錄

當網頁有變動時：

• UI 會顯示「變更次數」
• 點進去可看到紅色（刪除）/綠色（新增）比對內容
• 可以選擇略過空白差異、時間戳等

🔧 常用操作

✅ 適用場景

• 商品價格變化追蹤
• 網頁公告是否更新
• 訂票、招生、報名通知
• 自己架設的簡易監控系統

📎 官方網站與原始碼

• GitHub: https://github.com/dgtlmoon/changedetection.io

---

### 👉 儲存檔案指令

你可以在 Linux / Ubuntu 用這樣方式存成檔案：

```bash
nano changedetection-setup.md
# 貼上內容後 Ctrl+O 存檔，Ctrl+X 離開

或用任何你喜歡的編輯器（如 VSCode）直接貼上這份內容。

需要我幫你加上通知設定（例如 Telegram 或 email）說明到這份教學裡嗎？

Claude Code 完整自動化開發指南

目錄

1. 基本概念
2. 安裝與設置
3. 命令使用方式
4. 自動化模式詳解
5. 夜間自動化設置
6. Token 管理與監控
7. CLAUDE.md 優化實戰
8. Token 節省攻略
9. 效率提升技巧
10. 高級工作流程
11. 吳恩達 x Anthropic 官方免費課程
12. 進階整合技巧
13. 社群最佳實踐
14. 實戰建議
15. 實用腳本範例
16. 安全考量與最佳實踐
17. 故障排除

基本概念

Claude Code 是 Anthropic 的命令行工具，讓開發者可以直接在終端中與 Claude 協作進行編程任務。

主要特性

• 完整代碼庫感知：理解整個項目結構和模式
• 直接文件操作：編輯文件、執行命令、管理 git 操作
• 自主執行：可執行複雜的多步驟工作流程
• 上下文保持：維持項目慣例的長期記憶
• 確定性自動化：使用 hooks 保證特定動作總是發生

安裝與設置

安裝步驟

# 通過 npm 安裝
npm install -g @anthropic-ai/claude-code

# 驗證安裝
claude --version

# 設置 API 密鑰
export ANTHROPIC_API_KEY="your-api-key-here"

# 或者初次使用時會提示輸入
claude auth

環境變數設置

# 添加到 ~/.bashrc 或 ~/.zshrc
export ANTHROPIC_API_KEY="your-api-key-here"

# 設置常用別名
alias cc="claude --dangerously-skip-permissions"
alias claude-auto="claude --dangerously-skip-permissions"

命令使用方式

基本命令格式

# 命令名稱是 claude（不是 claude-code）
claude [選項] [提示]

# 查看所有可用選項
claude --help
claude -h

常用命令選項

# 互動模式（預設）
claude

# 單次任務模式
claude -p "修復所有 lint 錯誤"

# 跳過權限確認
claude --dangerously-skip-permissions

# JSON 輸出格式
claude -p "分析代碼品質" --output-format json

# 詳細模式（調試用）
claude --verbose

# Headless 模式（CI/CD 用）
claude -p "執行測試" --output-format stream-json

自動化模式詳解

1. 預設模式（有權限確認）

claude

特點：

• 每個操作都需要確認
• 安全性最高
• 適合精確控制場景
• 會中斷工作流程

2. 完全自動化模式

claude --dangerously-skip-permissions

特點：

• 繞過所有權限檢查
• 不間斷執行直到完成
• 類似 "yolo 模式"
• 適合夜間自動化

3. Auto-Accept 模式

# 啟動後按 Shift+Tab 切換
claude
# 然後按 Shift+Tab 進入自動接受模式

特點：

• 部分自動化
• 可隨時切換
• 保持一定控制權

4. Print 模式（單次任務）

claude -p "具體任務描述"

特點：

• 非互動式
• 適合腳本化
• 執行完就結束

5. 任務排隊系統

# 啟動自動化模式後，可連續輸入多個任務
claude --dangerously-skip-permissions

# 然後輸入一系列任務（Claude 會智能排序執行）
"修復所有 lint 錯誤"
"運行完整測試套件並修復失敗測試"
"重構重複代碼"
"添加缺失的註解和文檔"
"優化性能瓶頸"

夜間自動化設置

適合夜間運行的任務類型

Bug 修復和建構問題

• 修復編譯錯誤
• 解決依賴衝突
• 修復測試失敗
• 處理 lint 警告
• 解決類型錯誤

代碼品質改善

• 重構重複代碼
• 添加單元測試
• 更新過時文檔
• 優化性能
• 改善錯誤處理

自動化維護

• 更新依賴版本
• 清理無用代碼
• 格式化代碼風格
• 生成 API 文檔
• 整理 git 歷史

夜間自動化啟動方式

方式一：直接啟動

# 睡前執行（在專案目錄中）
cd /path/to/your/project
claude --dangerously-skip-permissions

然後輸入任務清單：

檢查並修復所有建構錯誤
運行完整測試套件，修復所有失敗的測試
處理所有 ESLint 和 TypeScript 警告
重構重複代碼並提高可讀性
添加缺失的單元測試，確保覆蓋率達到 80%
更新依賴到最新穩定版本
生成或更新 API 文檔
優化數據庫查詢和 API 響應時間
添加錯誤處理和日誌記錄
清理無用的註解和死代碼

方式二：單行命令啟動

claude --dangerously-skip-permissions -p "執行完整的夜間維護：修復所有 bug、運行測試、重構代碼、更新文檔、優化性能"

Token 管理與監控

Token 使用監控工具

安裝監控工具

# CC Usage - CLI 工具用於管理和分析 Claude Code 使用情況
npm install -g cc-usage

# Claude Code Usage Monitor - 實時終端監控工具
npm install -g claude-code-usage-monitor

使用監控工具

# 查看 token 使用情況
cc-usage dashboard

# 實時監控
claude-code-usage-monitor

節省 Token 的策略

1. 代碼優化

• 使用簡潔變數名稱（i, j, e, el）
• 避免過長的函數和類名
• 刪除不必要的註解

2. 分階段執行

# 階段性執行而非一次性大任務
claude -p "階段1：只修復編譯錯誤"
# 完成後
claude -p "階段2：只運行並修復測試"
# 完成後  
claude -p "階段3：只重構重複代碼"

3. 使用壓縮指令

# 當對話接近上下文限制時
/compact

Token 耗盡自動重啟機制

監控腳本

#!/bin/bash
# token-monitor.sh

PROJECT_PATH="/path/to/your/project"
LOG_FILE="/tmp/claude-auto.log"

check_tokens() {
    # 檢查 token 使用情況（需要配合監控工具）
    remaining=$(cc-usage check-remaining)
    echo "剩餘 tokens: $remaining"
    
    if [ "$remaining" -lt 1000 ]; then
        return 1  # token 不足
    else
        return 0  # token 充足
    fi
}

while true; do
    if check_tokens; then
        echo "$(date): Tokens 充足，啟動 Claude..." | tee -a $LOG_FILE
        cd $PROJECT_PATH
        
        timeout 4h claude --dangerously-skip-permissions -p "
        繼續開發任務：
        1. 檢查並修復任何建構問題
        2. 運行測試並修復失敗項目
        3. 改善代碼品質
        4. 更新文檔
        完成後進入待機模式
        " | tee -a $LOG_FILE
        
    else
        echo "$(date): Token 不足，等待補充..." | tee -a $LOG_FILE
        sleep 3600  # 等待1小時
    fi
    
    sleep 300  # 5分鐘後再檢查
done

CLAUDE.md 優化實戰

您的精簡理念是對的

官方初始化產生的 CLAUDE.md 確實冗長，建議精簡至：

# 核心指令
請務必測試。
指定修改檔案：編輯 src/components/Button.tsx
使用專案既有架構模式
錯誤必須印 log 才處理
避免 over-engineering

# 工作流程
- 先討論方案再寫程式
- 每次修改後執行測試
- 提交前檢查 linting

更進階的 CLAUDE.md 技巧

• 分層管理：在不同目錄放置不同的 CLAUDE.md
  • 專案根目錄：全域規則
  • 各子模組：特定規則
• 動態更新：使用 # 鍵讓 Claude 自動更新 CLAUDE.md

Token 節省攻略

模型切換策略

/model haiku    # 基礎操作（成本僅 Opus 的 5.3%）
/model sonnet   # 中等複雜任務
/model opus     # 複雜架構設計

智能切換建議：

• 讀檔案、簡單修改 → Haiku
• 程式邏輯、重構 → Sonnet
• 架構設計、複雜 debug → Opus

上下文管理精髓

/clear          # 每完成一個任務就清空
/compact        # 保留重要資訊的壓縮
/cost           # 隨時監控使用量
/resume         # 從歷史恢復（省去重複輸入）

省 Token 的指令技巧

精簡指令模式：

# 壞習慣：冗長描述
請幫我分析這個檔案的程式碼結構，然後告訴我有什麼問題...

# 好習慣：直接指令
分析 src/utils.js 找出效能問題

批次操作：

# 一次處理多個任務
修正 src/*.ts 的型別錯誤 + 執行測試 + 更新文件

使用檔案路徑：

# 直接指定不用讓 Claude 搜尋
編輯 src/components/Button.tsx line 45-60

快取利用技巧

重複使用相同文件結構：

• Claude 會快取讀過的檔案
• 重新開啟專案時先讀取主要檔案
• 使用 @filename 快速引用

記憶管理：

# 建立專案記憶快照
/remember 專案架構使用 React + TypeScript + Vite

# 引用記憶避免重複說明
使用已記住的架構新增登入功能

ccusage 監控神器

npm install -g ccusage
ccusage daily               # 查看每日用量
ccusage blocks --live       # 實時監控
ccusage summary            # 週/月度報告
ccusage alerts             # 設定用量警告

效率提升技巧

Plan Mode 工作流程

think hard 如何重構這個模組？
ultrathink 設計這個功能的最佳架構

多工處理技巧

# 創建獨立工作樹（吳恩達課程推薦）
git worktree add ../project-feature-a feature-a
# 在不同工作樹同時運行多個 Claude Code

課程實戰技巧：

• 每個功能分支使用獨立工作樹
• 並行開發不同模組避免衝突
• 使用不同的 CLAUDE.md 管理各工作樹

權限管理優化

claude --dangerously-skip-permissions
alias claude='claude --dangerously-skip-permissions'

高級工作流程

測試驅動開發（TDD）

在 CLAUDE.md 中強制執行 TDD：

MUST: 先寫測試再寫程式碼
MUST: 每次修改後執行完整測試
MUST: 所有測試必須通過才能提交

自動化指令

# .claude/commands/refactor.md
重構指定檔案：
1. 分析現有程式碼結構
2. 識別改進機會
3. 保持 API 相容性
4. 執行完整測試

超級省 Token 密技

使用簡潔符號

# 標準指令
check src/api.js for bugs

# 符號簡化  
chk src/api.js bugs

# 極簡模式
fix: api.js:42 TypeError

預設模板指令

在 CLAUDE.md 中定義縮寫：

# 快捷指令
- `rf` = 重構檔案保持 API 不變
- `tdd` = 先寫測試再實作
- `perf` = 效能分析和優化
- `docs` = 更新 README 和註解

多檔案操作技巧

# 一次處理相關檔案
同時修改 Button.tsx + Button.test.tsx + Button.stories.tsx

# 使用 glob 模式
更新所有 components/**/*.tsx 的 props 介面

上下文切割策略

功能拆分：

• 每個功能一個 session
• 完成後立即 /clear
• 用 /resume 連接相關 session

檔案分組：

• 前端 session：只處理 UI 相關
• 後端 session：只處理 API/DB
• 測試 session：專門寫測試

快速除錯模式

# 直接貼錯誤訊息
TypeError: Cannot read property 'map' of undefined at line 42

# 不用多說，Claude 會自動定位和修復

利用 Git 歷史

# 讓 Claude 從 commit 學習
基於最近 3 個 commits 的模式修改登入功能

成本效益分析

• 輸入幾乎免費：大量上下文成本極低
• 輸出計價：實際產出越多花費越高
• 快取機制：重複內容可節省約 90% 成本

吳恩達 x Anthropic 官方免費課程

課程概況

課程名稱：Claude Code: A Highly Agentic Coding Assistant
合作方：DeepLearning.AI（吳恩達創辦）x Anthropic
講師：Elie Schoppik（Anthropic 技術教育主管）
時長：1小時50分鐘（共10個課程單元）
費用：完全免費
課程連結：https://www.deeplearning.ai/short-courses/claude-code-a-highly-agentic-coding-assistant/

完整教學大綱

學習目標

• 使用 Claude Code 探索、開發、測試、重構和除錯程式碼庫
• 透過 MCP 伺服器擴展 Claude Code 功能
• 在三個實務專案中應用最佳實踐

核心技能培養

• 理解 Claude Code 的架構設計
• 建立 CLAUDE.md 專案文檔管理
• 使用 escape/clear 指令管理上下文
• 利用 git worktrees 進行並行開發
• GitHub 整合和 Issues 管理
• MCP 伺服器連接（Figma、Playwright）

三大實戰專案

專案一：RAG 聊天機器人

• 探索前後端架構設計
• 新增功能模組
• 撰寫完整測試套件
• 程式碼重構優化

專案二：電商數據分析

• Jupyter notebook 重構
• 轉換為互動式儀表板
• 數據視覺化優化

專案三：Web 應用開發

• 基於 Figma 設計稿建立 Web 界面
• 使用 Playwright 進行 UI 設計改進
• 響應式界面開發

吳恩達的 AI 民主化願景

"AI 教育應該是大眾化、通識化，而不是只屬於少數精英"

這門課程體現了吳恩達的核心理念：

• 普及化學習：讓任何人都能掌握 AI 工具
• 實務導向：專注於真實工作場景應用
• 全球培育：已培育超過 700 萬名 AI 人才

課程亮點特色

高度自主性

• Claude Code 能以最少人工輸入自主規劃、執行、改進程式碼
• 跨會話記憶和協作能力
• 通過 hooks 調用外部工具

企業級應用

• 真實專案案例研究
• 團隊協作工作流程
• 生產環境最佳實踐

前瞻技術整合

• MCP（Model Context Protocol）伺服器
• GitHub Issues 自動化
• Figma 設計稿直接轉程式碼

進階整合技巧

IDE 協同作業

• 與 Cursor 無縫整合
• 支援 VS Code、JetBrains 系列

MCP 工具擴展

npm install context7 browsermcp puppeteer

吳恩達課程重點 MCP 伺服器：

• Figma MCP：直接從設計稿生成程式碼
• Playwright MCP：自動化 UI 測試和改進
• GitHub MCP：Issues 管理和自動化

實戰應用場景：

# Figma 設計稿轉程式碼
使用 Figma MCP 將設計稿轉換為 React 元件

# 自動化測試
通過 Playwright MCP 建立完整的 E2E 測試

Git 整合工作流程

• 自動分析 commit 歷史
• 整合 GitHub Issues
• 生成週報摘要
• 自動化 PR 審查

社群最佳實踐

新手建議

1. 從 Codebase Q&A 開始
2. 逐步導入程式碼編輯功能
3. 善用內建工具（bash、測試等）
4. 建立專案特定的工具清單

團隊協作

• 共享 CLAUDE.md 設定檔
• 建立統一的提示詞模板
• 制定一致的程式碼風格規範
• 撰寫專案專屬最佳實踐文件

超省錢使用模式

學生/個人開發者

• 95% 使用 Haiku 模式
• 只有卡關才切換 Sonnet
• 善用 /compact 和 /clear
• 月花費控制在 $10 以下

小團隊策略

• 一人主導 Claude Code 操作
• 其他人提供需求和驗收
• 共享一個付費帳號降低成本
• 建立內部知識庫減少重複查詢

企業級使用

• 採用 Max Plan 無限制方案
• 建立企業級 CLAUDE.md 模板
• 整合 CI/CD 自動化流程
• 定期檢討和優化使用模式

實戰建議

適合

• 大型程式碼重構
• 新功能快速原型
• Bug 調查與修復
• 程式碼審查與優化
• 自動化腳本開發

不適合

• 極度複雜的演算法設計
• 需大量人工判斷的 UI/UX
• 高度安全敏感的程式碼

終極省 Token 檢查清單

開始前檢查

• 選對模型（90% 任務用 Haiku）
• 清空上次的 context（/clear）
• 準備好檔案路徑和行數
• 寫好精簡的指令

進行中優化

• 避免讓 Claude 解釋或總結
• 用符號和縮寫替代長句
• 批次處理相關任務
• 直接貼錯誤訊息不要描述

完成後清理

• 立即 /clear 釋放 context
• 更新 CLAUDE.md 避免重複
• 檢查 /cost 確認花費
• 記錄高效的指令模式

月度回顧

• 分析 ccusage 報告
• 調整模型使用比例
• 優化 CLAUDE.md 模板
• 分享團隊最佳實踐

記住：輸入便宜、輸出昂貴。讓 Claude 少說話、多做事！ 💪

延伸學習資源

官方推薦課程

• 🎓 吳恩達 x Anthropic 免費課程
  https://www.deeplearning.ai/short-courses/claude-code-a-highly-agentic-coding-assistant/

• 📚 Claude Code 官方文件
  https://docs.anthropic.com/en/docs/claude-code

• 🛠 MCP 伺服器生態系統
  https://github.com/anthropic/mcp-servers

社群資源

• 💬 DeepLearning.AI 社群討論
  課程相關問題解答和經驗分享

• 🔧 GitHub Claude Code 整合範例
  實際專案應用案例和最佳實踐

持續學習建議

1. 完成吳恩達免費課程（1小時50分鐘）
2. 實際應用三大專案模式到自己的工作
3. 參與 DeepLearning.AI 社群討論
4. 定期關注 Anthropic 和 Claude Code 更新

"AI 的未來在於讓每個人都能成為更好的開發者" —— Andrew Ng

"每次都要糾正 AI 的就放進 CLAUDE.md" —— 迭代優化，是發揮 Claude Code 最大價值的關鍵。

實用腳本範例

1. 基本夜間自動化腳本

#!/bin/bash
# basic-auto-dev.sh

PROJECT_PATH="/path/to/your/project"
LOG_FILE="/tmp/claude-dev-$(date +%Y%m%d).log"

echo "$(date): 開始夜間自動化開發" | tee -a $LOG_FILE

cd $PROJECT_PATH

# 啟動完全自動化模式，設置最大6小時執行時間
timeout 6h claude --dangerously-skip-permissions -p "
🌙 夜間自動化開發任務清單：

## 第一優先級（必須完成）
1. 檢查並修復所有編譯錯誤
2. 解決建構失敗問題
3. 修復所有測試失敗

## 第二優先級（代碼品質）  
4. 處理所有 lint 警告和錯誤
5. 修復 TypeScript 類型錯誤
6. 重構重複代碼

## 第三優先級（改善和優化）
7. 添加缺失的單元測試
8. 更新過時的註解和文檔
9. 優化性能瓶頸
10. 清理死代碼和無用導入

## 第四優先級（維護）
11. 更新依賴到最新穩定版本
12. 生成 API 文檔
13. 整理 git 提交歷史

請按優先級順序執行，完成一個階段後報告進度。
如果遇到需要人工決策的問題，請詳細記錄並繼續下一個任務。
" | tee -a $LOG_FILE

exit_code=$?

if [ $exit_code -eq 124 ]; then
    echo "$(date): 6小時超時完成" | tee -a $LOG_FILE
elif [ $exit_code -eq 0 ]; then
    echo "$(date): 所有任務完成" | tee -a $LOG_FILE
else
    echo "$(date): 執行中斷，錯誤代碼: $exit_code" | tee -a $LOG_FILE
fi

echo "$(date): 夜間自動化結束，檢查日誌: $LOG_FILE" | tee -a $LOG_FILE

2. 循環重啟腳本

#!/bin/bash
# continuous-auto-dev.sh

PROJECT_PATH="/path/to/your/project"
LOG_FILE="/tmp/claude-continuous.log"
MAX_CYCLES=5  # 最多重啟5次

cd $PROJECT_PATH

for i in $(seq 1 $MAX_CYCLES); do
    echo "$(date): 開始第 $i/$MAX_CYCLES 輪開發循環" | tee -a $LOG_FILE
    
    timeout 2h claude --dangerously-skip-permissions -p "
    開發循環 $i：
    1. 檢查項目狀態
    2. 修復發現的問題  
    3. 改善代碼品質
    4. 如果沒有明顯問題，進行優化工作
    
    報告這輪完成的工作和發現的問題。
    " | tee -a $LOG_FILE
    
    echo "$(date): 第 $i 輪完成，休息5分鐘..." | tee -a $LOG_FILE
    sleep 300
done

echo "$(date): 所有循環完成" | tee -a $LOG_FILE

3. Cron 定時任務設置

# 編輯 crontab
crontab -e

# 添加以下任務：

# 每晚10點啟動夜間開發
0 22 * * * cd /path/to/project && /path/to/basic-auto-dev.sh

# 每6小時檢查一次（適合長期項目）
0 */6 * * * cd /path/to/project && claude --dangerously-skip-permissions -p "快速檢查並修復緊急問題" >> /tmp/claude-check.log 2>&1

# 每天早上8點生成開發報告
0 8 * * * cd /path/to/project && claude -p "生成昨夜開發工作摘要報告" > /tmp/daily-report-$(date +\%Y\%m\%d).txt

# 週末進行深度重構（每週六凌晨2點）
0 2 * * 6 cd /path/to/project && timeout 8h claude --dangerously-skip-permissions -p "執行深度代碼重構和架構優化"

4. 項目特定配置腳本

#!/bin/bash
# project-specific-setup.sh

PROJECT_PATH="/path/to/your/project"
cd $PROJECT_PATH

# 創建 CLAUDE.md 配置文件
cat > CLAUDE.md << 'EOF'
# 項目開發指南

## 技術棧
- Frontend: React + TypeScript + Tailwind CSS
- Backend: Node.js + Express + PostgreSQL  
- Testing: Jest + React Testing Library
- Build: Vite + ESBuild

## 代碼風格
- 使用 TypeScript 嚴格模式
- 遵循 ESLint + Prettier 規則
- 函數命名使用 camelCase
- 組件命名使用 PascalCase
- 常量使用 UPPER_CASE

## 測試要求
- 每個 API 端點都要有測試
- React 組件需要渲染測試
- 工具函數需要單元測試  
- 總覆蓋率需達到 80% 以上

## 常見任務命令
- 安裝依賴：`npm install`
- 啟動開發：`npm run dev`
- 運行測試：`npm test`
- 代碼檢查：`npm run lint`
- 代碼格式化：`npm run format` 
- 建構項目：`npm run build`
- 類型檢查：`npm run type-check`

## 部署流程
1. 確保所有測試通過
2. 更新版本號
3. 建構生產版本
4. 部署到 staging 環境測試
5. 部署到 production 環境

## 已知問題
- [ ] API 響應時間偶爾較慢
- [ ] 某些組件的 TypeScript 類型定義不完整
- [ ] 測試覆蓋率還未達到目標

## 優化目標
- [ ] 改善 API 性能
- [ ] 完善類型定義
- [ ] 增加測試覆蓋率
- [ ] 重構重複代碼
- [ ] 更新過時文檔
EOF

echo "CLAUDE.md 配置文件已創建"

# 設置 hooks（如果需要）
mkdir -p .claude/hooks

# 創建自動格式化 hook
cat > .claude/hooks/post-edit << 'EOF'
#!/bin/bash
# 文件編輯後自動格式化
if [[ "$CLAUDE_TOOL_OUTPUT" == *.js ]] || [[ "$CLAUDE_TOOL_OUTPUT" == *.ts ]] || [[ "$CLAUDE_TOOL_OUTPUT" == *.tsx ]]; then
    npm run format "$CLAUDE_TOOL_OUTPUT"
fi
EOF

chmod +x .claude/hooks/post-edit

echo "項目配置完成，可以開始使用 Claude Code"

安全考量與最佳實踐

安全措施

1. 備份策略

# 設置自動備份
# 在啟動 Claude 前執行備份
git add . && git commit -m "Pre-Claude backup $(date)"

# 使用專用分支進行 AI 開發
git checkout -b ai-development-$(date +%Y%m%d)

2. 容器化隔離（推薦）

# Dockerfile for safe Claude development
FROM node:18-alpine

WORKDIR /app
COPY . .

# 安裝 Claude Code
RUN npm install -g @anthropic-ai/claude-code

# 限制網路存取（可選）
# RUN apk add --no-cache iptables

CMD ["claude", "--dangerously-skip-permissions"]

# 使用 Docker 運行
docker build -t claude-dev .
docker run -it -v $(pwd):/app claude-dev

3. 權限配置替代方案

// ~/.claude.json - 較安全的權限設置
{
  "allowedTools": [
    "Read(*)",
    "Write(*.js,*.ts,*.tsx,*.json,*.md)",
    "Bash(npm *)",
    "Bash(git add *)",
    "Bash(git commit *)",
    "Edit(*)"
  ],
  "deniedTools": [
    "Bash(rm *)",
    "Bash(sudo *)", 
    "Bash(curl *)",
    "Bash(wget *)"
  ]
}

風險控制

風險評估

• 高風險：系統文件被誤刪
• 中風險：重要代碼被錯誤修改
• 低風險：配置文件被更改

預防措施

# 1. 定期備份
alias backup-before-claude="git add . && git commit -m 'Backup before Claude $(date)'"

# 2. 監控文件變化
alias show-claude-changes="git diff HEAD~1"

# 3. 快速回滾
alias undo-claude="git reset --hard HEAD~1"

故障排除

常見問題與解決方案

1. Token 用完

# 檢查使用量
claude --version  # 查看配額信息

# 等待重置或升級計劃
# 設置監控腳本自動重試

2. 權限問題

# 檢查權限設置
claude --help | grep permission

# 重新設置權限
/permissions  # 在 Claude 內部使用

3. 任務中斷

# 使用 /compact 壓縮上下文
/compact

# 重新啟動並要求繼續
claude --dangerously-skip-permissions -p "繼續之前未完成的開發任務"

4. 性能問題

# 清理 Claude 緩存
rm -rf ~/.claude/cache/*

# 重新啟動 Claude

調試技巧

1. 詳細模式

# 啟用詳細日誌
claude --verbose --dangerously-skip-permissions

2. 日誌分析

# 查看 Claude 日誌
tail -f ~/.claude/logs/claude.log

# 分析錯誤模式
grep "ERROR" ~/.claude/logs/* | head -20

3. 逐步調試

# 分步執行任務
claude -p "只檢查項目狀態，不要修改任何文件"
claude -p "只修復編譯錯誤，一次一個文件"
claude -p "只運行測試，報告結果"

總結

Claude Code 可以實現真正的「睡覺前啟動，早上看結果」的自動化開發工作流程。關鍵要素：

✅ 成功要素

1. 正確使用命令：claude（不是 claude-code）
2. 完全自動化：--dangerously-skip-permissions
3. 任務排隊：一次性輸入多個相關任務
4. Token 管理：監控使用量，設置自動重啟
5. 安全備份：使用 git 和定期備份
6. 腳本化：使用 shell 腳本或 cron 自動化

🚀 最佳實踐

• 在專用分支進行 AI 開發
• 設置 CLAUDE.md 項目配置文件
• 使用容器隔離提高安全性
• 定期監控和調整自動化腳本
• 保持任務具體明確，避免模糊指令

⚠️ 注意事項

• --dangerously-skip-permissions 有風險，需要適當預防措施
• Token 使用量需要監控，避免超額
• 複雜任務可能需要分階段執行
• 定期檢查和調整自動化策略

這樣的設置特別適合處理重複性維護任務、bug 修復、代碼品質改善和日常開發工作。

Claude Code 最佳實踐指南

講者介紹

Cal - Applied AI 團隊成員

• 一年半前加入 Anthropic，協助成立 Applied AI 團隊
• 專門幫助客戶在 Claude 上構建優秀產品
• 原本是 Claude Code 重度使用者，因週末使用量排行第一而被團隊注意
• 現為核心貢獻者，負責提示系統和工具評估

Claude Code 簡介

Claude Code 是一個純粹的程式開發代理，具備以下特點：

• 強大的終端機工具 - 建立/編輯檔案、使用終端機
• 代理性搜尋功能 - 像開發者一樣探索程式庫
• 智慧程式理解 - 透過 Glob、Grep、Find 等工具理解程式庫，無需索引或嵌入

五大應用場景

1. 探索新程式庫

• 快速熟悉團隊程式庫和開發模式
• 詢問功能實現位置
• 分析 Git 歷史和程式變化

2. 腦力激盪夥伴

• 讓 Claude 搜尋並提出 2-3 種解決方案
• 一起驗證方案後再開始實作

3. 建構和撰寫程式

• 從零建立應用程式
• 在現有程式庫中良好運作
• 自動撰寫單元測試、提交記錄和 PR 訊息

4. 部署和生命週期

• 使用 Headless 模式，整合到 CI/CD
• 程式化地加入編碼代理

5. 支援和擴展

• 快速除錯錯誤
• 協助大型程式遷移（Java 升級、PHP 轉 React 等）

核心最佳實踐

Claude.md 檔案

• 工作目錄中的重要指令檔案
• 可放置專案概覽、測試方法、風格指南
• 支援專案級和個人級設定

權限管理

• 善用自動接受模式（Shift+Enter）
• 設定常用命令自動批准
• 聰明使用權限加速工作流程

整合設定

• 安裝更多 CLI 工具（如 GitHub CLI）
• 連接 MCP 伺服器擴展功能
• 優先選擇知名 CLI 工具而非 MCP 伺服器

上下文管理

• 200,000 字元上下文視窗
• 使用 /clear 重新開始
• 使用 /compact 總結並繼續工作

高效工作流程

計劃導向

• 先要求搜尋和計劃，再開始實作
• 觀察待辦清單，必要時按 Escape 調整方向

智慧程式開發

• 採用測試驅動開發 (TDD)
• 小幅度修改和定期提交
• 執行 TypeScript 檢查和程式格式化

視覺輔助

• 使用截圖引導和除錯
• 上傳 mock 圖片建立網站

進階技巧

多 Claude 並行

• 同時運行多個 Claude 處理不同任務
• 使用 tmux 或不同分頁協調工作

善用 Escape 鍵

• 即時停止並重新導向 Claude
• 雙擊 Escape 跳回對話歷史

工具擴展

• 探索 MCP 伺服器
• 無頭自動化整合 GitHub Actions

最新功能

模型切換

• 使用 /model 查看當前模型
• 在 Sonnet 和 Opus 間切換

工具呼叫間思考

• Claude 4 支援工具呼叫間的深度思考
• 更好的問題解決和除錯能力

IDE 整合

• VS Code 和 JetBrains 整合
• 自動識別當前檔案和工作環境

結語

Claude Code 是程式開發的遊戲規則改變者！持續關注 GitHub 上的 Anthropic/Claude-Code 取得最新更新。

一個半月高強度Claude Code使用後感受

六月中旬某個悶熱的夜晚，在初淺嘗試使用API Key幫我迅速完成了一個任務後，我毫不猶豫地點下了Claude Max的訂閱按鈕。作為一個「買斷制」時代的遺老，每月一兩百美金的訂閱對當時的我來說還是太超前了。但是在一個半月之後回頭望去，看著那些按照API計價的被我燒掉的價值3000多美金的token，我似乎撿到了一個超大便宜？不過最近Anthropic 宣布了新的weekly限制，想來大概針對的就是我這種「重度」用戶吧。所以近幾天來我也在研究有沒有其他替代方案，可以讓我從這種限制中解脫出來。不過嘗試了一圈下來（包括CC接其他API，也包括像Codex/Gemimi/Qwen/Crush/Amp/AugmentCode等等），似乎一時半會兒在這個領域Claude Code (後文用CC指代) 還是沒有競爭對手。既然還得續費，那不如階段性地做一個總結，來記錄下這一個半月使用CC的一些感受吧。

Vibe Coding的迭代速度

說到vibe coding，最讓我震撼的其實不是模型有多智能或者是能完成什麼尖端任務，而是由它帶來的產品迭代速度的提升。有個有意思的現象：Claude Code本身就是Anthropic內部dogfooding的產物：從六月中旬我開始使用到現在，短短一個半月時間裡，我們見證了很多嶄新的功能：自定義命令讓我們避免重複輸入一樣的prompt，Hooks功能可以在各種事件觸發時自動執行命令，Subagent則解決了上下文窗口的限制問題。這種更新頻率，放在傳統軟件開發時代簡直是天方夜譚。

不光是CC，整個AI輔助開發領域都在以令人眩暈的速度前進。幾天甚至幾小時完成一個產品，不再是不可能的任務。

不過，這種加速帶來了一個有趣的悖論：AI確實解放了開發者的雙手，讓我們不用再糾結於那些繁瑣的樣板代碼。但另一方面，當所有人都開上了「法拉利」，賽道上的競爭反而變得更加激烈了。以前你可以精心打磨一個功能，現在？競爭對手可能已經用AI快速迭代了三四個版本了。手工匠人式的打磨方式，無疑將被卷死在沙灘上。

說實話，有時候我會懷念那個慢工出細活的年代。但現實就是這樣，技術的車輪滾滾向前，你要麼跟上，要麼被碾過。去適應和利用它，而不是被裹挾前進，可能才是新時代的立命之本。如果這篇文章你只能記住一句話，那我希望是這句：在vibe coding時代，千萬別讓工具把自己逼死。效率是提高了，但人還是人，我們需要的不僅僅是更快的開發速度，還有思考的時間和生活的空間。

從傳統Editor AI的轉換

在投身CC之前，我也算是各種AI編輯器的老用戶了。從最早期的Cursor，到後來的Windsurf，再到GitHub Copilot和各種VS Code插件如Cline，基本上市面上叫得出名字的我都試過。但說實話，這些Editor AI工具並沒有像CC這樣給我帶來那麼大的衝擊和震撼。

我想，這類編輯器工具最大的問題是可能是缺少全局感。想像一下你使用這些編輯器AI時的經典場景：打開一個文件，選中幾行代碼，然後讓AI幫你改改。這種交互模式天然就把開發者的思維框在了當前文件甚至當前這幾行的範圍內。這種模式對於剛從傳統編程過渡到AI輔助編程的開發者來說，確實是個不錯的起點。畢竟，你還保留著對代碼的掌控感：AI寫得不好？沒關係，我隨時準備自己上。但問題是，如果你真的想進入深度的vibe coding狀態，讓AI發揮最大潛力，這種隨時準備接管的心態反而會成為阻礙。人類開發者的干預時機和直接下場寫代碼的時候越少，最終呈現出的效率和效果反而越好。

另外更致命的是同步問題：AI在上下文中認為文件是A狀態，實際文件已經被開發者插手改成B狀態了，然後你讓AI基於它的認知繼續修改，結果可想而知：要麼產生混亂，要麼AI需要再讀一遍所有內容。有時候光是解決這種不同步帶來的問題，花的時間就比寫代碼還多。

而命令行工具從理念上就不同：沒有華麗的界面，沒有實時的代碼提示，開發者在過程中難以直接插手「微調」。但恰恰是這種簡陋，反而讓它能夠更深入地理解和操作整個項目。它不會被某個文件或某幾行代碼限制視野，而是從項目的根目錄開始，建立起對整個代碼庫的認知。沒有了編輯器這個中間層，開發者想直接修改代碼變難了，這在某種程度上「強迫」你更多地依賴和使用AI，給它更多信息和反饋，這反而能發揮出更大的效能。

當然，我不是說編輯器AI就一無是處。本質上，當前兩者的差異更多來自於使用方式和模型質量，而非架構設計。CC背靠Anthropic這棵大樹，模型質量自然沒得說。更關鍵的是，它可以肆無忌憚地使用token（雖然最近加了weekly限制），這種量大管飽的豪橫，確實在末端引起了質變，讓最終效果好了不止一個檔次。如果讓編輯器AI也能隨便燒token，可能效果未必會差到哪裡去。

但現實就是現實，至少在當下，如果你想體驗真正的vibe coding，CC可能是唯一選擇。

認識CC的邊界和長處

就像所有工具一樣，CC或者說AI輔助編程，也有自己擅長和不擅長的領域。認清這些邊界，才能讓你的vibe coding之旅更加順暢。

如果你讓CC分析一段複雜的代碼邏輯，理解各個模塊之間的調用關係，然後畫一張時序圖或者架構圖，它會完成得相當出色。這種需要理解和總結的任務，正是LLM的看家本領。又或者，你想快速實現一個算法、搭建一個項目框架、編寫測試用例，CC都能給你滿意的答案。

但是，千萬別指望它在所有場景下都能大殺四方。比如說，你想在整個代碼庫裡做一次全局的變量重命名，或者進行某些需要精確匹配的複雜重構，那老老實實用IDE的重構功能會靠譜得多。LLM畢竟說到底也只是一個概率生成器，這類需要100%準確性的任務，從起源上就不是LLM的強項。如果你真的需要使用AI幫助完成這類任務，那麼請它寫一段腳本去執行並修改代碼，往往會比直接指揮它去修改文件，要來的靠譜。

還有個更現實的問題：訓練數據的偏差。CC在處理前端代碼或者TypeScript時簡直如魚得水，各種框架信手拈來，CSS炫技讓人眼花繚亂，最新的API也了如指掌。但換成iOS/Swift開發？那可就是另一番景象了。各種過時的API用法是家常便飯，有時乾脆臆造一些不存在的方法，幻覺嚴重，而更冷門的語言和框架情況則更加糟糕。訓練集豐富程度的差異直接決定了模型在不同領域的表現。

市面上也存在著其他不少基於命令行的code agent，像是Crush，Gemini CLI等等。但實測下來，它們現在和CC還存在很大差距。CC作為「軟硬件一體」解決方案帶來了巨大的優化空間：Anthropic既是模型提供方，又是工具開發方，這種垂直整合讓他們可以針對具體使用場景進行深度優化。這就像蘋果的生態系統——當你同時控制硬件和軟件時，能做到的事情遠超各自為戰的組合。其他競品要麼受限於模型能力，要麼受限於工具設計，很難達到CC這種渾然一體的使用體驗。

思考先行還是實踐先行

CC提供了一個很有意思的功能：Plan Mode。在這個模式下，你可以先和AI進行充分的討論，制定詳細的實施計劃，然後再開始實際的編碼工作。這就引出了一個有趣的話題：我們是應該追求先想清楚再動手，還是先動手搞出東西來之後再慢慢改？

在傳統軟件開發領域，這個爭論也由來已久。瀑布派說要先設計後實現，敏捷派說要快速迭代。到了AI時代，這個問題又有了新的含義。

我見過兩種極端的使用方式。第一種是「規劃魔」：進入Plan Mode後，和AI討論個把小時，上下文用光兩三次，從架構設計到具體實現，從錯誤處理到性能優化，事無巨細地規劃每一個細節。等到真正開始寫代碼時，基本上AI就是照著計劃一步步執行。另一種則是「莽夫流」：上來就是一句「給我實現一個XXX功能」，然後就看著AI噼里啪啦地寫代碼，寫完了發現不對再改，改完了又發現新問題，如此循環往復。

哪種方式更好？也許乍看下來先規劃再執行更好？但我的答案可能會讓你失望：要看情況。

如果你是個經驗豐富的開發者，對項目架構已經有了清晰的認識，那麼先進行充分的規劃確實能讓後續的實現更加順暢。特別是對於那些需要遵循特定架構模式的既有項目，Plan Mode能幫你確保AI生成的代碼符合項目規範。我自己就經常在Plan Mode裡和AI討論：「我們的項目使用了MVVM架構，新功能應該怎麼拆分到各個層？」 「這部分內容已經有類似實現了，你需要參考現有實現和模式」，這種討論能讓AI更好地理解項目的整體結構，生成的代碼質量更高，開發者對具體代碼的掌控也更好。

但如果你對某個技術棧完全不熟悉，或者正在做一個全新的探索性項目，那麼「先幹起來」可能反而是更好的選擇。這種情況下，很多時候你根本不知道自己不知道什麼。所以與其空想，不如讓AI先寫個原型出來，跑起來看看效果，發現問題再迭代。這種方式特別適合那些「短平快」的項目，或者你只是想快速驗證一個想法。

我個人的偏好？我更喜歡先進入Plan Mode，和AI討論後再開始實施。對我來說，日常維護已有代碼庫的工作是占大頭的，我需要更穩定和可靠的迭代，先plan有利於我掌控全局。但在接觸新技術棧時，我也不太願意直接莽起來。不同技術棧下，很多開發的理念是共通的：如何組織可維護的架構（不僅為了人類，也為了AI今後進行維護，合理的組織結構還是必要的），如果調度和安排代碼以保證高效，各個模塊的連接方式等。就算是新技術棧，適當的討論相比無腦梭哈，也提供了一種更有效的學習方式。但是這樣做的代價是慢，如果著急上線功能，或者寫的是可以無視代碼質量的「快消品」，那麼事無巨細的plan可能就不太適用了。

最後想說的是，Plan Mode還有個隱藏的好處：它能幫你整理思路。有時候你覺得自己想清楚了，但真要說出來或者寫下來，才發現還有很多細節沒考慮到。和AI的對話過程，其實也是一個自我梳理的過程。這算是「橡皮鴨調試法」的變種，在vibe coding時代依然很有價值。

Claude Code的Best practices 官方博文中介紹了幾種常見的workflow，比如：

• 探索，計劃，編碼，提交
• 編寫測試，提交，編碼，迭代，提交
• 編寫代碼，截圖，迭代

相比於直接用prompt命令CC開始幹活，先指導它對代碼庫的現狀進行理解，往往會得到更好的結果。參考這些常見workflow並逐漸發展出自己的使用AI的style，也是一種成長。

小步迭代還是放飛自我

在手工編程時代，一天能寫幾百行代碼就算是高產了。但vibe coding徹底改變了遊戲規則：現在，你可以在十幾分鐘內生成上千行代碼，甚至一口氣完成整個項目。這種「生產力爆炸」帶來了一個新問題：我們應該如何使用這種能力？

我見過的使用方式大致分兩派。一派是「小步快跑」：每次只讓AI完成一個小功能，驗證沒問題後再進行下一步。另一派是「一步到位」：直接把整個需求扔給AI，讓它一次性生成所有代碼。更極端的，還有人會開啟--dangerously-skip-permissions模式（也就是所謂的yolo模式），讓AI可以不經確認就執行任何操作。

兩種方式我都深度嘗試過，結論是：如果能選，小步迭代往往總是更好的選擇。

舉個例子，有次我想重構一個模塊，大概涉及七八個文件的修改。我當時想，既然AI這麼厲害，那讓它一次性搞定吧！於是我詳細描述了需求，然後就看著CC開始瘋狂輸出代碼。幾分鐘後，上千行代碼的修改完畢，編譯也通過了。我心想：這也太爽了吧！

然而，實際開始嘗試時，噩夢開始了。首先是一個小bug，因為上千行的修改肯定是懶得看的，所以只能描述情況，讓AI去修復；修復過程中又引入了新問題；再修復，又有新問題…幾輪下來，代碼庫已經面目全非。由於一次性改動太多，開發者失去了掌控，對於修改不理解，也就無法辨別哪些修改是必要的，哪些又是AI為了修復新bug臨時加上的。最後的結果，往往只能是git reset整個修改，重新開始。

這類經歷讓我明白了一個道理：AI生成代碼的能力很強，但它對整體架構的把握和長期維護的考慮還是有限的。一次性生成太多代碼，就像是在黑暗中狂奔——你可能跑得很快，但也可能一頭撞上牆。而且，當出現問題時，調試的複雜度會呈指數級增長。

相比之下，小步迭代的好處顯而易見：

• 可控性高：每次只改動一小部分，出問題了也容易定位和回滾。
• 能夠理解：你能跟上AI的思路，理解每一步在做什麼。
• 質量保證：可以在每一步後進行測試，確保代碼質量。
• 學習機會：通過觀察AI的實現方式，你也能學到新東西。

當然，我不是說「放飛自我」就完全不可取：在進行新功能實現時，如果已經進行了充分討論和規劃，那麼確實不太需要人類的監督，CC就可以完成大部分工作。如果你真的想嘗試「放飛自我」的開發方式，我有幾個建議：

• 必須有完善的測試：採用TDD的方式，先寫測試（當然這也是AI來寫），再讓AI實現功能。這樣至少能保證基本的正確性。
• 做好版本控制：在開始之前創建新分支，隨時準備回滾。
• 分模塊進行：即使要一次性完成很多功能，也盡量按模塊來組織，不要把所有東西混在一起。
• 交叉評審：AI生成的代碼看起來能跑，但可能隱藏著各種問題，對於生成的代碼，不要照單全收。最簡單的方式，就是找到另一個AI，將變更餵進去，看看有什麼需要改進的地方，這種迭代往往能收穫不錯的結果。

任務規模和上下文制約

人類和AI在某個方面驚人地相似：處理小任務時遊刃有餘，面對大項目就容易手忙腳亂。對CC來說，這個問題更加明顯，因為它還要面對一個硬性限制——200k的上下文窗口。在當前動輒模型給1M窗口的年代，這個限制又是確實相當痛苦。

體感上來說，普通使用個十幾二十分鐘，你就會看到上下文使用量飆到90%以上。這時候CC就像一個塞滿東西的行李箱，再想往裡裝點什麼都困難。更糟糕的是，如果在執行任務的過程中觸發了自動壓縮，整個agent可能會陷入混亂，忘記自己在做什麼，或者陷入死循環重複做一件事。

所以，如何在有限的上下文窗口內完成複雜任務，就成了使用CC的一門必修課。

任務拆解是關鍵

與其給AI一個籠統的「幫我完成XXX系統」的需求，不如先把大任務拆解成具體的小任務。這一步最好在Plan Mode中進行，讓AI幫你一起梳理。比如：

我：我想實現一個用戶認證系統，幫我拆解需求
AI：好的，讓我們拆解一下需要完成的任務：
1. 設計數據庫表結構（用戶表、會話表等）
2. 實現註冊功能（驗證、加密、存儲）
3. 實現登錄功能（驗證、生成token）
4. 實現中間件（驗證token、刷新機制）
5. 添加測試用例
...

對於一個session難以完成的任務，可以讓AI把討論內容進行文檔化，保存到項目裡（比如dev-note/auth-implementation-plan.md）。這樣，即使換了新的session，你也可以讓AI讀取這個文檔，快速恢復上下文。

使用Subagent

CC最近推出的Subagent功能在一定程度上緩解了這個問題。在以前，當CC使用Task工具進行任務時，實際上是在一個全新的上下文中進行工作。這相當於擴展了主Session的上下文窗口。

以前我們只能通過prompt技巧來「誘導」CC使用Task工具，效果時好時壞。現在有了專門的subagent配置，穩定性大大提升。你可以為不同類型的任務創建專門的agent：

• 代碼分析agent：專門負責理解現有代碼結構
• 代碼審查agent：檢查代碼質量和潛在問題
• 測試agent：編寫和運行測試用例
• Git agent：處理代碼提交和PR

通過合理鏈式調用這些agent，即使是大型任務也有機會能在同一個Session裡有條不紊地完成。每個agent都在獨立的上下文中工作，不會相互干擾，也不會耗盡主session的上下文。

在合適的時機手動compact

雖然CC會自動進行上下文壓縮，但我的經驗是：主動出擊會更好。當你看到上下文使用量接近用滿時，不妨手動執行/compact命令。這可以讓壓縮發生在一個更自然的斷點進行。比如剛完成一個功能模塊，或者剛跑完一輪測試。這時候壓縮，AI不太會丟失重要信息。而如果等到自動壓縮，可能正好在你改代碼改到一半的時候觸發，那就很容易出問題。

另一個技巧是：對於相對獨立的任務，乾脆新開一個session。反正你已經把任務計劃文檔化了，新session讀取文檔就能快速上手。這比在一個快要爆炸的session裡硬撐要明智得多。

當前在AI輔助編程中，上下文窗口依然是稀缺資源，要像管理內存一樣管理它。合理規劃、及時清理、必要時「換個房間」，才能讓vibe coding的體驗保持流暢。

善用命令和周邊工具

Command和Hooks

我有個暴論：凡是重複了兩次以上的類似prompt都應該用命令來表述！

每次都輸入類似的prompt真的非常無趣：「運行測試並修復失敗的用例」、「提交代碼時請使用規範的commit message」…如果你發現自己在重複類似的請求，立刻停下來，花一分鐘配置一個command。

Command相比subagent有個巨大的優勢：它擁有完整的當前會話上下文。如果你的任務和當前正在進行的工作高度相關，那麼command的效率會更高。比如我常用的幾個：

• /test-and-fix：運行測試，如果有失敗自動嘗試修復
• /review：對當前修改進行代碼審查，給出改進建議
• /commit-smart：分析改動，生成合適的commit message並提交

至於Hooks，說實話我用得不多。理論上它能在特定事件觸發時自動執行命令，比如每次提交前自動運行測試。但實際使用中，我更喜歡保持一定的控制權，不太喜歡太多自動化的東西在背後悄悄運行。不過這純屬個人偏好，如果你的工作流比較固定，Hooks確實能省不少事。

MCP

通過MCP補充模型不知道的知識。我最常用的幾個場景：

1. 最新的Apple文檔 Apple的文檔頁面大量使用JavaScript渲染，因此CC的WebFetch抓不到內容。但通過apple-docs-mcp，我可以獲取最新最準確的API文檔。這對iOS開發來說簡直是救命稻草。

2. 項目管理集成 通過mcp-atlassian連接JIRA，可以讓CC直接讀取和更新任務狀態，或者自動將分析的情況和實現進行回覆，保持溝通暢通。

3. LSP支持 CC暫時還原生支持LSP，但通過mcp-language-server，可以獲得準確的代碼補全和類型信息。特別是對於那些CC不太熟悉的語言，這個功能價值巨大。

配置MCP可能需要一點時間，但絕對物有所值。它讓CC從一個通用的工具變成了為你量身定制的助手。

編譯、分析和測試

永遠記住：AI生成的代碼，未經測試都是廢品。

我的工作流程通常是這樣的：

• 在CLAUDE.md中詳細列出項目的編譯命令、測試命令、linter配置
• 每完成一個小功能，立即編譯
• 編譯通過後，運行相關測試
• 測試通過後，運行linter和formatter

聽起來很繁瑣？其實配置好之後，這些都可以通過簡單的命令完成和subagent。關鍵是要讓這些步驟成為習慣，而不是等全部寫完再說。

如果你的項目支持TDD，那就更好了。先讓AI根據需求寫測試，然後再實現功能。這樣生成的代碼質量通常會高很多，因為AI有了明確的目標。

當然，根據編譯器的廢柴程度（你們大概應該知道我在說誰..）和項目的規模，編譯一次的時間代價可能會很大。這種情況下，我會拆分模塊，盡量只去編譯改過的模塊。如果這比較困難，那麼也可以使用git worktree來創建多個工作目錄：這樣你可以讓多個任務並行進行，互不干擾，也算是彌補等待編譯所帶來的時間損失。

Code之外，大有可為

別把CC只當成寫代碼的工具，它的能力遠不止於此。

我現在的日常使用場景：

• 代碼提交和PR：寫完代碼後，直接讓CC分析改動、生成commit message、推送代碼、創建PR。它生成的PR描述往往比我自己寫的還要清晰。
• 撰寫技術文檔和wiki: 讓CC分析代碼生成API文檔、更新README、編寫使用示例。它的文檔往往更加規範和完整，甚至不會出現語法錯誤。
• JIRA更新：完成任務後，讓CC更新ticket狀態、添加評論回覆用戶、甚至創建新的子任務。再也不用在網頁上點來點去了。
• 數據處理：需要批量處理文件、轉換格式、清洗數據？以前我會寫腳本，現在直接描述需求讓CC來做。而且每次需求不同時，不用維護一堆一次性腳本了。

更有意思的是CC解鎖了隨時隨地工作的可能性。通過像是VibeTunnel或者任意手機SSH客戶端，配合Tailscale，我可以在任何地方連接到家裡的工作機器，用手機指揮CC幹活。雖然不適合與CC進行複雜的計劃和交互，但處理一些簡單的需求，比如跑個腳本、修個小bug，更新下文檔什麼的，是完全沒問題的。出門在外突然想到什麼，立刻就能實現，這種感覺很奇妙。

最後，個人強烈推薦配一個好的麥克風。在vibe coding時代，用語音輸入描述需求，比打字更加自然流暢。現在的語音識別已經很準確了，而中英文混雜也能處理得很好。想不到當年為了當遊戲主播買的麥克風，吃灰這麼多年後，終於在今天找到了真正的用武之地。

當然，Mac系統自帶的語音輸入是幼兒園級別，從準確性和易用性上都不值一提。你肯定需要一款AI轉譯的app，我也試用過一些，總結幾個當前市面上的優秀選擇：

• MacWhisper：以前買的，現在在用，原生macOS app，作者支持速度很快。
• VoiceInk：提供開源以供確認，隱私安全，付費省心。
• Wispr Flow：訂閱制，小貴，但勝在UI漂亮，UX流暢。

它們都是很不錯的選擇，功能也都類似。除了基礎的語音識別和輸入外，再配合轉譯後接入LLM進行文本潤色/修改的能力，根據不同場景將我的語言自動轉為合適的文字和格式。這些app把人機交互提升了一個檔次，語音輸入的內容往往比我自己勞心勞力組織的文字還要清晰精確。現在，絕大多數情況下，我和同事用不同語言交流時，以及自己在書寫PR和各種文檔時，我幾乎也都是說中文，然後讓AI當我的「同傳」轉換為合適的目標語言，以此確保準確和及時。

體感降智和更多限制

接下來要說的內容，有些是我自己的感受，有些是社區裡朋友們的吐槽。很多東西無法證實或證偽，大家權且一聽。

Opus遠強於Sonnet

這幾乎是板上釘釘的事實：Opus的效果比Sonnet好很多。畢竟價格擺在那裡，Opus是Sonnet的5倍。100美金的max訂閱，5小時時間窗口的Opus只能跑幾個小任務額度就用光了。200美金的訂閱也只是勉強夠用。

如果你是100美金檔的用戶，建議養成手動切換模型的習慣。日常用Sonnet處理簡單任務，遇到複雜的架構設計或者棘手的bug，再切到Opus。

時間玄學

這個聽起來很離譜，但確實有體感：美國半夜（也就是北京時間的白天）的效果比美國白天要好。實際上軟件開發最活躍的還是中美兩國，而Anthropic在中國其實是沒有正規渠道能用的。所以可能是因為美國夜裡使用的人少，服務器壓力小，從而模型性能不會退化？總之，如果北京時間大清早遇到無法解決的問題，留到下午時段處理，可能會有驚喜。

降智疑雲

最讓人擔心的是這個：個人體感，前一個月的使用體驗明顯比最近兩週要好。開始我以為是自己的錯覺，但社區裡抱怨的聲音也越來越多。合理的猜測是大量開發者湧入導致的資源緊張。就像一個原本只供應100人的自助餐廳，突然來了1000人，菜品質量下降幾乎是必然的。結合最近Anthropic尋求新的融資的新聞和推出weekly限制的政策，想要在這個定價和使用策略下盈利，似乎是不太可能的。

限制的陰霾

從8月底開始，weekly限制正式實施。雖然官方說是為了公平使用，但誰都知道這背後是算力不足的無奈。而且不排除未來會有更嚴格的限制。

這讓我想起一個老段子：中國先解決顯卡問題，還是美國先解決電力問題？在這兩個問題解決之前，AI發展的瓶頸可能不是算法，而是最基礎的硬件資源。

一些應對策略

面對這些限制，可能我們不得不採取一些「省著用」的技巧：

• 分級使用：簡單任務用Sonnet，複雜任務才上Opus
• 錯峰使用：避開美國工作時間，選擇服務器負載低的時段
• 提高prompt質量：一次說清楚，減少來回對話消耗的token
• 合理使用subagent：把消耗大的任務分配給subagent
• 保持多個選擇：雖然CC目前最強，但保持對其他工具的關注

總結和未來展望

一個半月的CC使用經歷，有驚喜，有擔憂，有對未來的憧憬，也有對現實的無奈。但總的來說，我感受到的是自己切實地站在在歷史的進程之中。Vibe coding不僅僅是一種新的編程方式，更是一種全新的思維模式。它要求我們重新思考什麼是編程、什麼是創造、什麼是價值。在這個AI與人類共舞的時代，願我們都能找到屬於自己的節奏。

最後，回到文章開頭的那句話：在vibe coding時代，千萬別讓工具把自己逼死。技術是為人服務的，不是相反；工作是讓人有機會追尋和思考自我的，而不是讓自己迷失。保持這份清醒，可能比掌握任何具體的技巧都更重要。

Slack Socket Mode 完整設定指南

🎯 目標

使用 Python 監控 Slack 頻道訊息

📋 前置作業

1. 建立 Slack App

1. 前往 Slack API 網站
2. 點擊 "Create New App"
3. 選擇建立方式：
   • From scratch: 從零開始建立（需手動設定）
   • From an app manifest: 使用預設檔案（推薦快速設定）

如果選擇 From an app manifest，使用以下設定：

display_information:
  name: Message Monitor
description:
  Simple message monitoring bot
features:
  bot_user:
    display_name: Monitor Bot
oauth_config:
  scopes:
    bot:
      - channels:history
      - channels:read
      - chat:write
settings:
  event_subscriptions:
    bot_events:
      - message.channels
  interactivity:
    is_enabled: false
  org_deploy_enabled: false
  socket_mode_enabled: true
  token_rotation_enabled: false

2. 設定權限 (如果選擇 From scratch)

1. 左側選單 → "OAuth & Permissions"
2. 在 "Bot Token Scopes" 添加：
   • channels:history - 讀取頻道歷史
   • channels:read - 讀取頻道資訊
   • chat:write - 發送訊息
3. 點擊 "Install to Workspace"
4. 授權後取得 Bot User OAuth Token (xoxb-開頭)

3. 啟用 Socket Mode

1. 左側選單 → "Socket Mode"
2. 開啟 "Enable Socket Mode"
3. 建立 App-Level Token：
   • 輸入 Token 名稱
   • 勾選 connections:write scope
   • 點擊 "Generate"
4. 取得 App-Level Token (xapp-開頭)

4. 設定事件訂閱 (如果選擇 From scratch)

1. 左側選單 → "Event Subscriptions"
2. 開啟 "Enable Events"
3. 在 "Subscribe to bot events" 添加：
   • message.channels - 頻道訊息事件

🔧 Python 程式設定

1. 安裝必要套件

pip install slack-bolt

2. 基本監控程式碼

from slack_bolt import App
from slack_bolt.adapter.socket_mode import SocketModeHandler

# 替換成你的 tokens
SLACK_BOT_TOKEN = "xoxb-你的-bot-token"
SLACK_APP_TOKEN = "xapp-你的-app-token"

# 初始化 Slack App
app = App(token=SLACK_BOT_TOKEN)

# 監聽所有頻道訊息
@app.message("")
def handle_message(message, say):
    user = message.get('user', '未知使用者')
    text = message.get('text', '')
    channel = message.get('channel', '')
    
    print(f"頻道: {channel}")
    print(f"使用者: {user}")
    print(f"訊息: {text}")
    print("-" * 50)

# 啟動應用程式
if __name__ == "__main__":
    print("🚀 開始監控 Slack 頻道訊息...")
    print("按 Ctrl+C 停止程式")
    
    handler = SocketModeHandler(app, SLACK_APP_TOKEN)
    handler.start()

3. 除錯版本程式碼

from slack_bolt import App
from slack_bolt.adapter.socket_mode import SocketModeHandler
import logging

# 啟用詳細日誌
logging.basicConfig(level=logging.DEBUG)

# 你的 tokens
SLACK_BOT_TOKEN = "xoxb-你的-bot-token"
SLACK_APP_TOKEN = "xapp-你的-app-token"

# 初始化 Slack App
app = App(token=SLACK_BOT_TOKEN)

# 監聽所有事件來除錯
@app.event("message")
def handle_message_event(event, say, logger):
    logger.info(f"收到事件: {event}")
    
    # 避免處理 bot 自己的訊息
    if event.get('bot_id') or event.get('subtype'):
        print(f"⏭️  忽略 bot 訊息或特殊訊息: {event.get('subtype', 'bot_message')}")
        return
    
    user = event.get('user', '未知使用者')
    text = event.get('text', '')
    channel = event.get('channel', '')
    
    print(f"✅ 收到訊息！")
    print(f"頻道: {channel}")
    print(f"使用者: {user}")
    print(f"訊息: {text}")
    print(f"時間戳: {event.get('ts', '')}")
    print("-" * 50)

# 監聽連接狀態
@app.event("hello")
def handle_hello(event, logger):
    logger.info("Socket Mode 連接成功！")
    print("🎉 成功連接到 Slack！")

# 監聽錯誤
@app.error
def custom_error_handler(error, body, logger):
    logger.exception(f"錯誤: {error}")
    print(f"❌ 發生錯誤: {error}")

# 測試連接
def test_connection():
    try:
        response = app.client.api_test()
        if response["ok"]:
            print("✅ API 連接正常")
        else:
            print("❌ API 連接失敗")
    except Exception as e:
        print(f"❌ API 測試失敗: {e}")

if __name__ == "__main__":
    print("🚀 開始監控 Slack 頻道訊息...")
    print("🔧 除錯模式啟用")
    
    # 測試連接
    test_connection()
    
    # 啟動 Socket Mode
    try:
        handler = SocketModeHandler(app, SLACK_APP_TOKEN)
        print("⚡ Socket Mode Handler 啟動中...")
        handler.start()
    except Exception as e:
        print(f"❌ 啟動失敗: {e}")

🏃‍♂️ 執行和測試

1. 取得必要的 Tokens

Bot Token 位置：

• 路徑：OAuth & Permissions → "OAuth Tokens for Your Workspace"
• 格式：xoxb- 開頭
• 用途：API 呼叫

App Token 位置：

• 路徑：Socket Mode → App-Level Tokens
• 格式：xapp- 開頭
• 用途：Socket Mode 連接

2. 邀請 Bot 到頻道

重要：Bot 必須被邀請到頻道才能監控！

在目標頻道中輸入：

/invite @你的bot名稱

或透過頻道設定手動加入 Bot。

3. 執行程式

python your_script.py

4. 測試驗證

1. 確認看到 "🎉 成功連接到 Slack！"
2. 在已邀請 Bot 的頻道發送訊息
3. 觀察終端機是否有輸出

🔍 監控範圍說明

✅ 會監控到的訊息：

• 公開頻道中的訊息（Bot 已加入）
• 私人頻道中的訊息（Bot 已被邀請）
• 直接提及 Bot 的訊息

❌ 不會監控到的訊息：

• 私人訊息（除非直接傳給 Bot）
• Bot 未加入的頻道
• Bot 沒有權限的頻道

🎛️ 進階設定

監控特定頻道

TARGET_CHANNEL = "C1234567890"  # 替換成你的頻道 ID

@app.message("")
def handle_message(message, say):
    channel = message.get('channel', '')
    
    if channel == TARGET_CHANNEL:
        # 只處理特定頻道的訊息
        user = message.get('user', '未知使用者')
        text = message.get('text', '')
        print(f"✅ 目標頻道訊息！")
        print(f"頻道: {channel}")
        print(f"使用者: {user}")
        print(f"訊息: {text}")

取得頻道 ID

1. 在 Slack 中右鍵點擊頻道名稱
2. 選擇「複製連結」
3. 連結中的 /C123456789/ 就是頻道 ID

環境變數設定（推薦）

建立 .env 檔案：

SLACK_BOT_TOKEN=xoxb-your-bot-token-here
SLACK_APP_TOKEN=xapp-your-app-token-here

安裝套件：

pip install python-dotenv

程式碼修改：

import os
from dotenv import load_dotenv

load_dotenv()

SLACK_BOT_TOKEN = os.environ.get("SLACK_BOT_TOKEN")
SLACK_APP_TOKEN = os.environ.get("SLACK_APP_TOKEN")

🚨 常見問題排除

1. 程式執行但收不到訊息

• ✅ 確認 Bot 已被邀請到頻道
• ✅ 檢查 OAuth Scopes 權限
• ✅ 確認 Event Subscriptions 設定正確
• ✅ 檢查 Socket Mode 已啟用

2. 連接失敗

• ✅ 確認 Tokens 正確
• ✅ 檢查網路連接
• ✅ 確認 App 已安裝到工作區

3. 檢查 Bot 是否在頻道中

在頻道輸入：

/who

應該會看到 Bot 在成員列表中。

📝 注意事項

• Socket Mode 適合開發和測試
• 生產環境建議使用 HTTP 模式
• 妥善保管 Tokens，不要提交到版本控制
• Bot 需要適當的權限才能監控訊息
• 避免在程式中處理 Bot 自己發送的訊息

DuckDNS 註冊與自動更新 IP 教學

🧾 步驟一：註冊帳號

1. 前往 https://www.duckdns.org/
2. 使用 Google 或 GitHub 其中一個帳號登入

🌐 步驟二：建立子網域

1. 登入後，在首頁輸入你想要的子網域名稱（例如：gamegame）
2. 點選 add domain，建立 gamegame.duckdns.org

🛠️ 步驟三：取得你的 Token

• 登入後首頁會顯示你的專屬 Token（例如：xxxxxxxxxxxxxxxxxxxxxxxxx）

🔄 步驟四：設定自動更新 IP

建議在家用伺服器或樹莓派上設定，讓 DDNS 持續更新 IP

1. 建立資料夾與更新指令

mkdir -p ~/duckdns
echo url="https://www.duckdns.org/update?domains=gamegame&token=xxxxxxxxxxxxxxxxxxxxxxxxx&ip=" | curl -k -o ~/duckdns/duck.log -K -

• gamegame 請換成你自己的子網域
• token= 後面換成你自己的 Token

2. 設定 crontab 每 5 分鐘自動更新

crontab -e

在打開的編輯器中加上以下一行：

*/5 * * * * echo url="https://www.duckdns.org/update?domains=gamegame&token=xxxxxxxxxxxxxxxxxxxxxxxxx&ip=" | curl -k -o ~/duckdns/duck.log -K -

儲存後即可每 5 分鐘更新一次 IP，讓你的子網域自動指向你目前的公网 IP。

✅ 測試確認

你可以在瀏覽器中打開：

https://www.duckdns.org/update?domains=gamegame&token=xxxxxxxxxxxxxxxxxxxxxxxxx&ip=

如果回傳 OK 表示成功！

免費 DNS 與 SSL 完整指南 2025

🌐 免費 DNS 服務

DNS 服務可以分為兩大類：公共 DNS 解析器（用來加速上網）和動態 DNS 服務（用來獲得免費網域名）。

🚀 公共 DNS 解析器（提升上網速度）

這些服務可以取代你的 ISP DNS，提供更快、更安全的網路瀏覽體驗。

1. Cloudflare DNS（推薦）

• 主要 DNS：1.1.1.1
• 次要 DNS：1.0.0.1
• 特色：
  • 全球最快的 DNS 服務之一
  • 強調隱私保護，24 小時內刪除記錄
  • 支援 DNS-over-HTTPS (DoH) 和 DNS-over-TLS (DoT)
  • 內建惡意網站防護
• 適用於：注重速度和隱私的用戶

2. Google Public DNS

• 主要 DNS：8.8.8.8
• 次要 DNS：8.8.4.4
• 特色：
  • Google 強大網路支援，穩定可靠
  • 支援 DNSSEC 安全擴展
  • 全球廣泛可用
  • 免費且快速
• 適用於：需要穩定性的一般用戶

3. Quad9

• 主要 DNS：9.9.9.9
• 次要 DNS：149.112.112.112
• 特色：
  • 免費安全 DNS 服務
  • 自動阻擋惡意網站和釣魚網站
  • 不記錄個人資料
  • 全球 150+ 解析叢集
• 適用於：注重安全性的用戶

4. OpenDNS（Cisco）

• 主要 DNS：208.67.222.222
• 次要 DNS：208.67.220.220
• 特色：
  • 免費版本包含基本安全防護
  • 家庭版可過濾不當內容
  • 支援自訂過濾選項
  • 99.9% 正常運行時間
• 適用於：家庭用戶和需要內容過濾的環境

🏠 動態 DNS 服務（免費網域名）

這些服務提供免費的子網域，讓你可以用域名訪問家裡的伺服器。

1. DuckDNS（強烈推薦）

• 網址：https://www.duckdns.org
• 免費額度：5 個子網域
• 網域格式：your-name.duckdns.org
• 特色：
  • 完全免費，由 AWS 託管
  • 設定極其簡單
  • 支援 IPv4 和 IPv6
  • 提供多平台自動更新腳本
  • 256 位元 SSL 安全連線
  • 不需註冊，OAuth 登入即可
• 缺點：只能使用 duckdns.org 子網域
• 適用於：新手和快速部署

2. No-IP

• 網址：https://www.noip.com
• 免費額度：3 個主機名
• 網域格式：多種選擇，如 yourname.ddns.net
• 特色：
  • 老牌 DDNS 服務商
  • 多種域名選項
  • 提供客戶端軟體
  • 100% 正常運行時間保證
• 缺點：
  • 免費帳戶需每 30 天確認一次
  • 免費版功能受限
• 適用於：需要多樣域名選擇的用戶

3. Dynu

• 網址：https://www.dynu.com
• 免費額度：4 個子網域
• 網域格式：yourname.dynu.net 或自訂域名
• 特色：
  • 支援頂級域名和三級域名
  • 全球名稱伺服器
  • IP 地址追蹤
  • 100% 正常運行時間
  • 提供客戶端程式
• 適用於：需要進階功能的用戶

4. FreeDNS (afraid.org)

• 網址：https://freedns.afraid.org
• 免費額度：5 個子網域 + 無限自訂域名
• 特色：
  • 功能強大且靈活
  • 支援多種記錄類型
  • 社群共享域名
  • 完全免費
• 缺點：介面較舊，設定複雜
• 適用於：進階用戶

🔒 免費 SSL 憑證服務

SSL 憑證對於網站安全至關重要，以下是主要的免費 SSL 提供商。

1. Let's Encrypt（推薦）

• 提供者：非營利組織 Internet Security Research Group
• 憑證效期：90 天（可自動更新）
• 特色：
  • 完全免費且受所有主流瀏覽器信任
  • 支援通配符憑證（*.example.com）
  • 自動化部署和更新
  • 全球超過 2.5 億個域名使用
  • 支援多種驗證方式（HTTP、DNS、TLS-SNI）
• 使用工具：Certbot
• 安裝指令：

# Ubuntu/Debian
sudo apt install certbot python3-certbot-nginx

# 申請憑證
sudo certbot --nginx -d your-domain.com

# 自動更新（crontab）
0 3 * * * /usr/bin/certbot renew --quiet

2. Cloudflare Universal SSL

• 網址：https://www.cloudflare.com
• 憑證效期：1 年（自動更新）
• 特色：
  • 免費計劃包含 SSL
  • 支援通配符憑證
  • 全球 CDN 加速
  • DDoS 防護
  • 設定極其簡單
  • 支援 HTTP/2 和 HTTP/3
• 設定步驟：
  1. 註冊 Cloudflare 帳戶
  2. 添加你的域名
  3. 更改域名伺服器到 Cloudflare
  4. 自動獲得 SSL 憑證
• 適用於：需要 CDN 和額外安全功能的用戶

3. Google Trust Services

• 提供者：Google
• 憑證效期：90 天
• 特色：
  • Google 的 CA 服務
  • 與 GlobalSign 交叉簽署，相容性佳
  • 支援現代加密算法
• 主要用於：Google Cloud Platform 用戶

4. SSL.com（免費試用）

• 提供者：SSL.com
• 免費期間：90 天試用
• 特色：
  • 高相容性（99.9% 瀏覽器支援）
  • 支援多種驗證類型
  • 企業級功能
• 適用於：需要測試企業級 SSL 的用戶

🛠️ 實際部署範例

使用 DuckDNS + Let's Encrypt 的完整設定

步驟 1：設定 DuckDNS

# 1. 到 https://www.duckdns.org 用 GitHub/Google 登入
# 2. 創建子網域，例如：myserver.duckdns.org
# 3. 記下你的 token

# 4. 創建更新腳本
mkdir ~/duckdns
nano ~/duckdns/duck.sh

腳本內容：

#!/bin/bash
DOMAIN="myserver"
TOKEN="your-token-here"
curl -k -o ~/duckdns/duck.log "https://www.duckdns.org/update?domains=${DOMAIN}&token=${TOKEN}"

步驟 2：設定自動更新

chmod +x ~/duckdns/duck.sh

# 設定 crontab 每 5 分鐘更新
crontab -e
# 加入這行：
*/5 * * * * ~/duckdns/duck.sh

步驟 3：申請 Let's Encrypt SSL

# 安裝 Certbot
sudo apt install certbot python3-certbot-nginx

# 申請憑證
sudo certbot --nginx -d myserver.duckdns.org

# 設定自動更新
echo "0 3 * * * /usr/bin/certbot renew --quiet" | sudo crontab -

使用 Cloudflare 的設定

步驟 1：轉移 DNS 到 Cloudflare

# 1. 註冊 Cloudflare 帳戶
# 2. 添加你的域名
# 3. 更改域名伺服器到 Cloudflare 提供的 NS
# 4. 等待 DNS 傳播（通常 24 小時內）

步驟 2：啟用 SSL

# 在 Cloudflare Dashboard：
# 1. 進入 SSL/TLS 設定
# 2. 選擇 "Full" 或 "Full (strict)" 模式
# 3. 啟用 "Always Use HTTPS"
# 4. 啟用 "Automatic HTTPS Rewrites"

🔧 進階配置建議

DNS 效能最佳化

# 測試不同 DNS 的速度
dig @1.1.1.1 google.com
dig @8.8.8.8 google.com
dig @9.9.9.9 google.com

# 設定多個 DNS（/etc/resolv.conf）
nameserver 1.1.1.1
nameserver 8.8.8.8
nameserver 9.9.9.9

SSL 安全最佳化

# Nginx SSL 最佳實踐
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512;
ssl_prefer_server_ciphers off;
ssl_session_cache shared:SSL:10m;

# 安全標頭
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
add_header X-Frame-Options DENY always;
add_header X-Content-Type-Options nosniff always;

💡 選擇建議

DNS 服務選擇

• 速度優先：Cloudflare DNS (1.1.1.1)
• 安全優先：Quad9 (9.9.9.9)
• 穩定優先：Google DNS (8.8.8.8)
• 家庭使用：OpenDNS

動態 DNS 選擇

• 新手推薦：DuckDNS
• 功能需求：Dynu
• 穩定需求：No-IP
• 進階用戶：FreeDNS

SSL 憑證選擇

• 技術用戶：Let's Encrypt
• 簡單需求：Cloudflare Universal SSL
• 企業用戶：Let's Encrypt + 商業 CA 備份

✅ 檢查清單

部署完成後確認：

DNS 檢查

• DNS 解析正確：nslookup your-domain.com
• IP 更新正常：檢查 DDNS 服務面板
• 自動更新腳本運作正常

SSL 檢查

• HTTPS 正常訪問
• 憑證有效期：瀏覽器鎖頭圖示
• SSL 評級：https://www.ssllabs.com/ssltest/
• 自動更新設定完成

安全檢查

• HTTP 自動跳轉 HTTPS
• 安全標頭正確設定
• 防火牆規則適當

這些免費服務已經能滿足大多數個人和小型企業的需求，而且品質完全不輸付費服務！

DuckDNS + Let's Encrypt 一鍵安裝指南

📖 簡介

這個指南提供一個完整的自動化腳本，幫你快速設定：

• DuckDNS 免費動態 DNS 服務
• Let's Encrypt 免費 SSL 憑證
• Nginx 網頁伺服器配置
• 自動化更新 IP 和 SSL 憑證

完成後你將擁有一個完全免費、安全的 HTTPS 網站！

🚀 功能特色

✅ 自動化安裝

• 一鍵安裝所有必要套件
• 自動配置所有服務
• 智能錯誤檢測和處理

✅ DuckDNS 設定

• 自動創建更新腳本
• 每 5 分鐘自動更新 IP
• 詳細的運行日誌

✅ SSL 憑證管理

• 自動申請 Let's Encrypt 憑證
• 90 天到期前自動更新
• 完整的 HTTPS 重定向

✅ Nginx 配置

• 最佳化的安全設定
• 美觀的預設首頁
• 準備好的反向代理配置

📋 前置準備

1. DuckDNS 帳戶設定

# 1. 前往 https://www.duckdns.org
# 2. 使用 GitHub/Google 帳戶登入
# 3. 創建一個子網域，例如：myserver
# 4. 記下你的 Token（類似：a7c4d0ad-114e-40ef-ba1d-d217904a50f2）

2. 伺服器需求

• 作業系統：Ubuntu 18.04+ 或 Debian 9+
• 權限：sudo 或 root 存取權限
• 網路：可連接外網的伺服器
• 端口：80 和 443 端口對外開放

🛠️ 一鍵安裝腳本

創建安裝腳本

創建檔案 setup_duckdns_ssl.sh：

#!/bin/bash

# DuckDNS + Let's Encrypt 自動化安裝腳本
# 使用方法: sudo bash setup_duckdns_ssl.sh

set -e

# 顏色定義
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# 輸出函數
print_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

print_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

print_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

print_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# 檢查是否為 root 用戶
check_root() {
    if [[ $EUID -ne 0 ]]; then
        print_error "此腳本需要 root 權限運行"
        print_info "請使用: sudo bash $0"
        exit 1
    fi
}

# 獲取用戶輸入
get_user_input() {
    print_info "=== DuckDNS + Let's Encrypt 設定 ==="
    echo
    
    # DuckDNS 設定
    read -p "請輸入你的 DuckDNS 子網域名稱 (不含 .duckdns.org): " DUCKDNS_DOMAIN
    if [[ -z "$DUCKDNS_DOMAIN" ]]; then
        print_error "網域名稱不能為空"
        exit 1
    fi
    
    read -p "請輸入你的 DuckDNS Token: " DUCKDNS_TOKEN
    if [[ -z "$DUCKDNS_TOKEN" ]]; then
        print_error "Token 不能為空"
        exit 1
    fi
    
    # 用戶設定
    read -p "請輸入要運行 DuckDNS 更新的用戶名稱 (預設: $SUDO_USER): " DUCK_USER
    DUCK_USER=${DUCK_USER:-$SUDO_USER}
    if [[ -z "$DUCK_USER" ]]; then
        print_error "用戶名稱不能為空"
        exit 1
    fi
    
    # 確認設定
    echo
    print_info "=== 設定確認 ==="
    echo "網域: ${DUCKDNS_DOMAIN}.duckdns.org"
    echo "Token: ${DUCKDNS_TOKEN:0:8}..."
    echo "用戶: $DUCK_USER"
    echo
    read -p "確認以上設定正確嗎? (y/N): " confirm
    if [[ ! "$confirm" =~ ^[Yy]$ ]]; then
        print_warning "安裝已取消"
        exit 0
    fi
}

# 安裝必要套件
install_packages() {
    print_info "更新套件列表並安裝必要工具..."
    
    apt update
    apt install -y curl cron certbot python3-certbot-nginx nginx
    
    print_success "套件安裝完成"
}

# 設定 DuckDNS
setup_duckdns() {
    print_info "設定 DuckDNS..."
    
    # 取得用戶家目錄
    USER_HOME=$(eval echo ~$DUCK_USER)
    DUCKDNS_DIR="$USER_HOME/duckdns"
    
    # 創建目錄
    mkdir -p "$DUCKDNS_DIR"
    
    # 創建更新腳本
    cat > "$DUCKDNS_DIR/duck.sh" << EOF
#!/bin/bash
# DuckDNS 自動更新腳本
# 由 setup_duckdns_ssl.sh 自動生成

DOMAIN="$DUCKDNS_DOMAIN"
TOKEN="$DUCKDNS_TOKEN"
LOG_FILE="\$HOME/duckdns/duck.log"

# 記錄時間
echo "\$(date): 開始更新 DuckDNS IP" >> "\$LOG_FILE"

# 更新 IP
curl -s "https://www.duckdns.org/update?domains=\$DOMAIN&token=\$TOKEN" -o "\$LOG_FILE.tmp"

# 檢查結果
if grep -q "OK" "\$LOG_FILE.tmp"; then
    echo "\$(date): IP 更新成功" >> "\$LOG_FILE"
else
    echo "\$(date): IP 更新失敗" >> "\$LOG_FILE"
    cat "\$LOG_FILE.tmp" >> "\$LOG_FILE"
fi

rm -f "\$LOG_FILE.tmp"
EOF
    
    # 設定權限
    chmod +x "$DUCKDNS_DIR/duck.sh"
    chown -R $DUCK_USER:$DUCK_USER "$DUCKDNS_DIR"
    
    # 執行一次測試
    print_info "測試 DuckDNS 更新..."
    sudo -u $DUCK_USER "$DUCKDNS_DIR/duck.sh"
    
    if grep -q "OK" "$DUCKDNS_DIR/duck.log"; then
        print_success "DuckDNS 設定成功"
    else
        print_error "DuckDNS 測試失敗，請檢查 Token 和網域名稱"
        cat "$DUCKDNS_DIR/duck.log"
        exit 1
    fi
}

# 設定 crontab
setup_crontab() {
    print_info "設定 DuckDNS 自動更新 (每5分鐘)..."
    
    USER_HOME=$(eval echo ~$DUCK_USER)
    CRON_CMD="*/5 * * * * $USER_HOME/duckdns/duck.sh"
    
    # 檢查是否已存在相同的 cron job
    if sudo -u $DUCK_USER crontab -l 2>/dev/null | grep -q "duck.sh"; then
        print_warning "DuckDNS cron job 已存在，跳過設定"
    else
        # 添加 cron job
        (sudo -u $DUCK_USER crontab -l 2>/dev/null; echo "$CRON_CMD") | sudo -u $DUCK_USER crontab -
        print_success "DuckDNS 自動更新已設定"
    fi
}

# 等待 DNS 傳播
wait_dns_propagation() {
    print_info "等待 DNS 記錄傳播..."
    FULL_DOMAIN="${DUCKDNS_DOMAIN}.duckdns.org"
    
    for i in {1..12}; do
        if nslookup "$FULL_DOMAIN" > /dev/null 2>&1; then
            print_success "DNS 記錄已生效"
            return 0
        fi
        print_info "等待 DNS 傳播... ($i/12)"
        sleep 10
    done
    
    print_warning "DNS 傳播可能需要更長時間，繼續進行 SSL 設定"
}

# 基本 Nginx 設定
setup_nginx_basic() {
    print_info "設定基本 Nginx 配置..."
    
    FULL_DOMAIN="${DUCKDNS_DOMAIN}.duckdns.org"
    NGINX_CONF="/etc/nginx/sites-available/$DUCKDNS_DOMAIN"
    
    # 創建基本配置（HTTP only，為了 Let's Encrypt 驗證）
    cat > "$NGINX_CONF" << EOF
server {
    listen 80;
    server_name $FULL_DOMAIN;
    
    # Let's Encrypt 驗證路徑
    location /.well-known/acme-challenge/ {
        root /var/www/html;
    }
    
    # 臨時首頁
    location / {
        root /var/www/html;
        index index.html;
    }
}
EOF
    
    # 創建簡單的首頁
    cat > "/var/www/html/index.html" << EOF
<!DOCTYPE html>
<html>
<head>
    <title>$FULL_DOMAIN</title>
    <style>
        body { font-family: Arial, sans-serif; text-align: center; margin-top: 100px; }
        .container { max-width: 600px; margin: 0 auto; }
        .success { color: #28a745; }
    </style>
</head>
<body>
    <div class="container">
        <h1 class="success">🎉 網站設定成功！</h1>
        <p>你的網域 <strong>$FULL_DOMAIN</strong> 已經可以正常訪問了。</p>
        <p>SSL 憑證正在設定中...</p>
        <hr>
        <p><small>Powered by DuckDNS + Let's Encrypt</small></p>
    </div>
</body>
</html>
EOF
    
    # 啟用網站
    ln -sf "$NGINX_CONF" "/etc/nginx/sites-enabled/"
    
    # 移除預設網站
    rm -f /etc/nginx/sites-enabled/default
    
    # 測試配置
    nginx -t
    systemctl reload nginx
    
    print_success "基本 Nginx 配置完成"
}

# 申請 Let's Encrypt SSL 憑證
setup_ssl() {
    print_info "申請 Let's Encrypt SSL 憑證..."
    
    FULL_DOMAIN="${DUCKDNS_DOMAIN}.duckdns.org"
    EMAIL="admin@${FULL_DOMAIN}"
    
    # 申請憑證
    certbot --nginx \
        --non-interactive \
        --agree-tos \
        --email "$EMAIL" \
        --domains "$FULL_DOMAIN" \
        --redirect
    
    if [[ $? -eq 0 ]]; then
        print_success "SSL 憑證申請成功"
    else
        print_error "SSL 憑證申請失敗"
        return 1
    fi
}

# 設定 SSL 自動更新
setup_ssl_auto_renewal() {
    print_info "設定 SSL 憑證自動更新..."
    
    # 檢查是否已有自動更新設定
    if crontab -l 2>/dev/null | grep -q "certbot renew"; then
        print_warning "SSL 自動更新已設定，跳過"
    else
        # 添加自動更新 cron job (每天凌晨3點檢查)
        (crontab -l 2>/dev/null; echo "0 3 * * * /usr/bin/certbot renew --quiet --nginx") | crontab -
        print_success "SSL 自動更新已設定"
    fi
}

# 最終檢查和優化
final_optimization() {
    print_info "進行最終優化..."
    
    FULL_DOMAIN="${DUCKDNS_DOMAIN}.duckdns.org"
    
    # 更新首頁，移除 "SSL 設定中" 訊息
    cat > "/var/www/html/index.html" << EOF
<!DOCTYPE html>
<html>
<head>
    <title>$FULL_DOMAIN</title>
    <meta charset="UTF-8">
    <style>
        body { 
            font-family: 'Segoe UI', Arial, sans-serif; 
            text-align: center; 
            margin: 0;
            padding: 50px 20px;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            min-height: 100vh;
            box-sizing: border-box;
        }
        .container { 
            max-width: 600px; 
            margin: 0 auto; 
            background: rgba(255,255,255,0.1);
            padding: 40px;
            border-radius: 15px;
            backdrop-filter: blur(10px);
        }
        .success { color: #4CAF50; }
        .badge { 
            display: inline-block;
            background: #4CAF50;
            color: white;
            padding: 5px 15px;
            border-radius: 20px;
            font-size: 14px;
            margin: 10px 5px;
        }
        .info { 
            background: rgba(255,255,255,0.1);
            padding: 20px;
            border-radius: 10px;
            margin: 20px 0;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>🎉 恭喜！網站設定完成</h1>
        <div class="badge">✅ HTTPS 已啟用</div>
        <div class="badge">🔒 SSL 憑證有效</div>
        <div class="badge">🔄 自動更新</div>
        
        <div class="info">
            <h3>網站資訊</h3>
            <p><strong>網域:</strong> $FULL_DOMAIN</p>
            <p><strong>服務:</strong> DuckDNS + Let's Encrypt</p>
            <p><strong>狀態:</strong> <span class="success">運行正常</span></p>
        </div>
        
        <p>你的網站現在已經:</p>
        <ul style="text-align: left; display: inline-block;">
            <li>✅ 支援 HTTPS 安全連線</li>
            <li>✅ SSL 憑證自動更新</li>
            <li>✅ DuckDNS IP 自動同步</li>
            <li>✅ 準備好部署你的應用</li>
        </ul>
        
        <hr style="margin: 30px 0; border: 1px solid rgba(255,255,255,0.3);">
        <p><small>Generated by DuckDNS + Let's Encrypt Auto Setup Script</small></p>
    </div>
</body>
</html>
EOF
    
    # 檢查服務狀態
    systemctl enable nginx
    systemctl enable cron
    
    print_success "最終優化完成"
}

# 顯示完成資訊
show_completion_info() {
    FULL_DOMAIN="${DUCKDNS_DOMAIN}.duckdns.org"
    USER_HOME=$(eval echo ~$DUCK_USER)
    
    echo
    print_success "=== 安裝完成！ ==="
    echo
    echo "📋 安裝摘要:"
    echo "  🌐 網域: https://$FULL_DOMAIN"
    echo "  🔒 SSL: Let's Encrypt (90天自動更新)"
    echo "  🔄 DuckDNS: 每5分鐘自動更新IP"
    echo "  👤 運行用戶: $DUCK_USER"
    echo
    echo "📁 重要檔案位置:"
    echo "  DuckDNS 腳本: $USER_HOME/duckdns/duck.sh"
    echo "  DuckDNS 日誌: $USER_HOME/duckdns/duck.log"
    echo "  Nginx 配置: /etc/nginx/sites-available/$DUCKDNS_DOMAIN"
    echo "  SSL 憑證: /etc/letsencrypt/live/$FULL_DOMAIN/"
    echo
    echo "🔧 常用管理指令:"
    echo "  查看 DuckDNS 日誌: tail -f $USER_HOME/duckdns/duck.log"
    echo "  手動更新 DuckDNS: $USER_HOME/duckdns/duck.sh"
    echo "  檢查 SSL 憑證: certbot certificates"
    echo "  手動更新 SSL: sudo certbot renew"
    echo "  重啟 Nginx: sudo systemctl restart nginx"
    echo
    echo "📅 自動化任務:"
    echo "  DuckDNS 更新: 每5分鐘"
    echo "  SSL 憑證更新: 每天凌晨3點檢查"
    echo
    print_info "現在可以訪問 https://$FULL_DOMAIN 測試你的網站！"
    echo
}

# 主要執行流程
main() {
    clear
    print_info "DuckDNS + Let's Encrypt 自動化安裝腳本"
    print_info "此腳本將幫你設定免費的動態DNS和SSL憑證"
    echo
    
    check_root
    get_user_input
    
    print_info "開始安裝..."
    install_packages
    setup_duckdns
    setup_crontab
    wait_dns_propagation
    setup_nginx_basic
    setup_ssl
    setup_ssl_auto_renewal
    final_optimization
    
    show_completion_info
}

# 執行主程式
main "$@"

📱 使用步驟

1. 下載並準備腳本

# 創建腳本檔案
nano setup_duckdns_ssl.sh

# 複製上面的腳本內容到檔案中
# 儲存並退出編輯器

# 給予執行權限
chmod +x setup_duckdns_ssl.sh

2. 執行安裝

# 使用 sudo 執行腳本
sudo bash setup_duckdns_ssl.sh

3. 輸入設定資訊

腳本會依序詢問：

• DuckDNS 子網域名稱：例如 myserver（不要包含 .duckdns.org）
• DuckDNS Token：從你的 DuckDNS 帳戶頁面複製
• 運行用戶：通常按 Enter 使用預設即可

4. 確認設定並等待完成

• 腳本會顯示設定摘要供你確認
• 確認後會自動安裝和配置所有服務
• 整個過程大約需要 5-10 分鐘

🎯 完成後的結果

✅ 你將擁有

• 安全的 HTTPS 網站：https://yourname.duckdns.org
• 自動 IP 更新：每 5 分鐘檢查並更新 IP 地址
• 自動 SSL 更新：憑證到期前自動更新
• 美觀的首頁：展示安裝成功和系統狀態

📁 重要檔案位置

~/duckdns/duck.sh              # DuckDNS 更新腳本
~/duckdns/duck.log             # 更新日誌檔案
/etc/nginx/sites-available/    # Nginx 網站配置
/etc/letsencrypt/live/         # SSL 憑證儲存位置
/var/www/html/index.html       # 網站首頁

🔧 日常管理指令

DuckDNS 管理

# 查看更新日誌
tail -f ~/duckdns/duck.log

# 手動執行更新
~/duckdns/duck.sh

# 查看 cron 任務
crontab -l

SSL 憑證管理

# 檢查憑證狀態
sudo certbot certificates

# 手動更新憑證
sudo certbot renew

# 測試自動更新
sudo certbot renew --dry-run

Nginx 管理

# 檢查配置語法
sudo nginx -t

# 重新載入配置
sudo systemctl reload nginx

# 重啟 Nginx
sudo systemctl restart nginx

# 查看狀態
sudo systemctl status nginx

🚀 部署你的應用

安裝完成後，你可以將 Django 應用部署到這個環境：

修改 Nginx 配置

# 編輯 Nginx 配置
sudo nano /etc/nginx/sites-available/yourname

# 添加反向代理到你的 Django 應用
location / {
    proxy_pass http://127.0.0.1:8000;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

# 重新載入配置
sudo systemctl reload nginx

Django 設定

# settings.py
ALLOWED_HOSTS = ['yourname.duckdns.org']
SECURE_SSL_REDIRECT = True
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')

🛡️ 安全性和最佳實踐

自動化任務檢查

# DuckDNS 更新：每5分鐘
*/5 * * * * /home/user/duckdns/duck.sh

# SSL 更新：每天凌晨3點
0 3 * * * /usr/bin/certbot renew --quiet --nginx

防火牆設定

# 開放必要端口
sudo ufw allow 22    # SSH
sudo ufw allow 80    # HTTP
sudo ufw allow 443   # HTTPS
sudo ufw enable

監控和備份

# 設定日誌輪轉
sudo nano /etc/logrotate.d/duckdns

# 內容：
/home/*/duckdns/duck.log {
    weekly
    rotate 4
    compress
    delaycompress
    missingok
    notifempty
}

🔍 故障排除

常見問題

1. DuckDNS 更新失敗

# 檢查日誌
cat ~/duckdns/duck.log

# 確認 Token 和網域名稱正確
# 手動測試更新
curl "https://www.duckdns.org/update?domains=yourname&token=yourtoken"

2. SSL 憑證申請失敗

# 檢查 DNS 解析
nslookup yourname.duckdns.org

# 確認防火牆開放 80 端口
sudo ufw status

# 手動申請憑證
sudo certbot --nginx -d yourname.duckdns.org

3. Nginx 配置錯誤

# 測試配置
sudo nginx -t

# 查看錯誤日誌
sudo tail -f /var/log/nginx/error.log

📞 支援和社群

• DuckDNS 官網：https://www.duckdns.org
• Let's Encrypt 文檔：https://letsencrypt.org/docs/
• Nginx 官方文檔：https://nginx.org/en/docs/

這個一鍵安裝腳本讓你能在幾分鐘內擁有一個完全免費、安全且自動化的 HTTPS 網站！

Buttplug Python 安裝設置指南

📦 安裝步驟

1. 安裝 Python 庫

pip install buttplug

2. 安裝 Intiface Desktop

• 下載：https://intiface.com/desktop/
• 這是 Buttplug 的圖形界面服務器，負責與硬件設備通信

3. 設備準備

• 確保你的設備已充電並開機
• 將設備設置為配對模式（通常是長按電源鍵）

🔧 配置 Intiface Desktop

1. 啟動 Intiface Desktop

• 打開應用程序
• 點擊 "Start Server" 開始服務器

2. 設備配對

• 在 Intiface 中點擊 "Devices" 頁面
• 點擊 "Start Scanning" 掃描設備
• 當你的設備出現在列表中時，點擊連接

3. 服務器設置

• 默認端口：12345
• 默認地址：ws://localhost:12345
• 確保 "Server" 標籤顯示 "Running"

🚀 快速開始

最簡單的範例

import asyncio
from buttplug.client import ButtplugClient, ButtplugClientWebsocketConnector

async def simple_example():
    client = ButtplugClient("測試應用")
    
    try:
        # 連接服務器
        connector = ButtplugClientWebsocketConnector("ws://localhost:12345")
        await client.connect(connector)
        print("已連接到服務器")
        
        # 掃描設備
        await client.start_scanning()
        await asyncio.sleep(5)  # 掃描5秒
        await client.stop_scanning()
        
        # 檢查設備
        if client.devices:
            device = client.devices[0]
            print(f"找到設備: {device.name}")
            
            # 振動測試
            await device.vibrate(0.5)  # 50%強度
            await asyncio.sleep(2)
            await device.stop()  # 停止
            
        else:
            print("未找到設備")
            
    except Exception as e:
        print(f"錯誤: {e}")
    finally:
        await client.disconnect()

# 運行範例
asyncio.run(simple_example())

🔍 常見問題排解

Q: 連接失敗 "Connection refused"

A: 檢查 Intiface Desktop 是否運行：

• 打開 Intiface Desktop
• 確認 "Server" 狀態為 "Running"
• 檢查端口設置（默認12345）

Q: 找不到設備

A: 設備配對問題：

1. 確保設備已開機且在配對模式
2. 在 Intiface Desktop 中先手動連接設備
3. 檢查設備是否被其他應用程序占用

Q: 振動命令無效果

A: 設備兼容性問題：

1. 確認設備支持振動功能
2. 檢查設備電量是否充足
3. 嘗試在 Intiface Desktop 中手動測試設備

Q: 權限錯誤（Linux/macOS）

A:

# Linux: 添加用戶到 dialout 組
sudo usermod -a -G dialout $USER

# 重新登錄或重啟系統

📱 支持的設備品牌

Buttplug 支持多個主流品牌：

🔥 完全支持

• Lovense 系列
• WeVibe 系列
• Kiiroo 系列
• Magic Motion 系列

⚡ 基本支持

• Satisfyer 部分型號
• LELO 部分型號
• Vorze 系列

📋 設備功能檢查

async def check_device_features(device):
    print(f"設備名稱: {device.name}")
    
    # 檢查執行器類型
    if hasattr(device, 'actuators'):
        for actuator in device.actuators:
            print(f"執行器類型: {actuator.actuator_type.name}")
            print(f"步進數: {actuator.step_count}")
    
    # 檢查傳感器
    if hasattr(device, 'sensors'):
        for sensor in device.sensors:
            print(f"傳感器類型: {sensor.sensor_type.name}")

🛡️ 安全使用提醒

代碼安全

• 始終使用 try-except 捕獲異常
• 程序結束前務必調用 device.stop()
• 使用 asyncio 避免阻塞

硬件安全

• 設定強度上限（建議不超過0.8）
• 避免長時間高強度運行
• 定期檢查設備溫度

隱私安全

• 本地運行，不向外部服務器發送數據
• Buttplug 是開源項目，代碼可審查

🔧 進階配置

自定義服務器地址

# 遠程服務器
connector = ButtplugClientWebsocketConnector("ws://192.168.1.100:12345")

# 不同端口
connector = ButtplugClientWebsocketConnector("ws://localhost:8080")

多客戶端處理

async def multi_client_example():
    # 可以創建多個客戶端
    client1 = ButtplugClient("應用1")
    client2 = ButtplugClient("應用2")
    
    # 但同一時間只有一個可以控制設備

自定義事件處理

@client.scanning_finished_handler
async def on_scan_finished():
    print("自定義掃描完成處理")

@client.device_added_handler  
async def on_device_added(device):
    print(f"自定義設備添加處理: {device.name}")

📚 相關資源

• 官方文檔: https://buttplug-developer-guide.docs.buttplug.io/
• Python API 文檔: https://buttplug-py.docs.buttplug.io/
• GitHub 倉庫: https://github.com/buttplugio/buttplug-py
• 社群討論: https://discord.buttplug.io/

🔄 版本兼容性

• Python: 3.7+
• Buttplug Protocol: v3.0+
• Intiface Desktop: 最新版本

記得定期更新庫以獲得最佳兼容性：

pip install --upgrade buttplug

Buttplug Python 簡易指南

📦 安裝步驟

1. 安裝 Python 庫

pip install buttplug

2. 下載 Intiface Desktop

• 下載地址：https://intiface.com/desktop/
• 安裝並啟動
• 點擊 "Start Server" 啟動服務器（默認端口：12345）

3. 設備配對

• 確保設備開機並進入配對模式
• 在 Intiface Desktop 的 "Devices" 頁面掃描並連接設備

🔧 功能說明

核心功能

• 統一控制：一套 API 控制多種品牌設備
• 多種模式：振動、旋轉、線性運動
• 安全機制：強度限制、超時保護
• 實時控制：低延遲設備響應

支持的設備類型

• 振動設備：各種震動棒、跳蛋等
• 旋轉設備：帶旋轉功能的設備
• 線性設備：活塞運動類設備
• 感測設備：可讀取電池、按鈕狀態等

📋 API 參考表格

客戶端連接 API

設備控制 API

設備屬性 API

事件處理 API

ActuatorType 類型表

連接器類型表

🐍 Python 範例代碼

1. 基礎連接範例

import asyncio
from buttplug.client import ButtplugClient, ButtplugClientWebsocketConnector

async def basic_example():
    # 創建客戶端
    client = ButtplugClient("我的應用")
    
    try:
        # 連接服務器
        connector = ButtplugClientWebsocketConnector("ws://localhost:12345")
        await client.connect(connector)
        print("✅ 已連接")
        
        # 掃描設備
        await client.start_scanning()
        await asyncio.sleep(3)  # 掃描3秒
        await client.stop_scanning()
        
        # 檢查設備
        if client.devices:
            device = client.devices[0]
            print(f"📱 設備: {device.name}")
            
            # 振動測試
            await device.scalar([{
                "Index": 0,
                "Scalar": 0.5,  # 50%強度
                "ActuatorType": "Vibrate"
            }])
            await asyncio.sleep(2)
            
            # 停止
            await device.stop()
        else:
            print("❌ 未找到設備")
            
    except Exception as e:
        print(f"❌ 錯誤: {e}")
    finally:
        await client.disconnect()

# 運行
asyncio.run(basic_example())

2. 設備事件處理

import asyncio
from buttplug.client import ButtplugClient, ButtplugClientWebsocketConnector

async def event_example():
    client = ButtplugClient("事件範例")
    
    # 設備連接事件
    @client.device_added_handler
    async def device_connected(device):
        print(f"🔗 設備已連接: {device.name}")
        
        # 自動測試新設備
        await device.scalar([{
            "Index": 0,
            "Scalar": 0.3,
            "ActuatorType": "Vibrate"
        }])
        await asyncio.sleep(1)
        await device.stop()
    
    # 設備斷開事件
    @client.device_removed_handler
    async def device_disconnected(device):
        print(f"🔌 設備已斷開: {device.name}")
    
    try:
        connector = ButtplugClientWebsocketConnector("ws://localhost:12345")
        await client.connect(connector)
        
        # 開始掃描
        await client.start_scanning()
        print("🔍 掃描中，請連接設備...")
        await asyncio.sleep(10)  # 等待10秒
        await client.stop_scanning()
        
    except Exception as e:
        print(f"❌ 錯誤: {e}")
    finally:
        await client.disconnect()

asyncio.run(event_example())

3. 設備控制類

import asyncio
import math
from buttplug.client import ButtplugClient, ButtplugClientWebsocketConnector

class SimpleController:
    def __init__(self):
        self.client = None
        self.device = None
    
    async def connect(self):
        """連接並找到第一個振動設備"""
        self.client = ButtplugClient("簡單控制器")
        connector = ButtplugClientWebsocketConnector("ws://localhost:12345")
        await self.client.connect(connector)
        
        await self.client.start_scanning()
        await asyncio.sleep(3)
        await self.client.stop_scanning()
        
        # 找到第一個振動設備
        for device in self.client.devices:
            if hasattr(device, 'actuators') and device.actuators:
                for actuator in device.actuators:
                    if actuator.actuator_type.name == 'Vibrate':
                        self.device = device
                        print(f"✅ 使用設備: {device.name}")
                        return True
        
        print("❌ 未找到振動設備")
        return False
    
    async def vibrate(self, intensity: float):
        """設定振動強度 (0.0-1.0)"""
        if not self.device:
            return
        
        await self.device.scalar([{
            "Index": 0,
            "Scalar": min(intensity, 0.8),  # 安全限制
            "ActuatorType": "Vibrate"
        }])
    
    async def stop(self):
        """停止振動"""
        if self.device:
            await self.device.stop()
    
    async def pulse_pattern(self, count=5):
        """脈衝振動模式"""
        for i in range(count):
            await self.vibrate(0.7)
            await asyncio.sleep(0.3)
            await self.stop()
            await asyncio.sleep(0.3)
        print(f"✅ 脈衝模式完成 ({count}次)")
    
    async def wave_pattern(self, duration=10):
        """波浪振動模式"""
        start_time = asyncio.get_event_loop().time()
        step = 0
        
        while (asyncio.get_event_loop().time() - start_time) < duration:
            intensity = 0.4 + 0.3 * math.sin(step * 0.3)
            await self.vibrate(intensity)
            step += 1
            await asyncio.sleep(0.1)
        
        await self.stop()
        print(f"✅ 波浪模式完成 ({duration}秒)")
    
    async def escalate_pattern(self):
        """遞增振動模式"""
        intensities = [0.2, 0.4, 0.6, 0.8]
        
        for intensity in intensities:
            print(f"   強度: {int(intensity*100)}%")
            await self.vibrate(intensity)
            await asyncio.sleep(2)
        
        await self.stop()
        print("✅ 遞增模式完成")
    
    async def disconnect(self):
        """斷開連接"""
        if self.device:
            await self.stop()
        if self.client:
            await self.client.disconnect()

# 使用範例
async def main():
    controller = SimpleController()
    
    try:
        if await controller.connect():
            # 測試不同模式
            await controller.pulse_pattern(3)
            await asyncio.sleep(1)
            
            await controller.wave_pattern(5)
            await asyncio.sleep(1)
            
            await controller.escalate_pattern()
    
    finally:
        await controller.disconnect()

asyncio.run(main())

4. 多設備控制

import asyncio
from buttplug.client import ButtplugClient, ButtplugClientWebsocketConnector

async def multi_device_example():
    client = ButtplugClient("多設備控制")
    
    try:
        connector = ButtplugClientWebsocketConnector("ws://localhost:12345")
        await client.connect(connector)
        
        await client.start_scanning()
        await asyncio.sleep(5)
        await client.stop_scanning()
        
        # 找到所有振動設備
        vibrating_devices = []
        for device in client.devices:
            if hasattr(device, 'actuators') and device.actuators:
                for actuator in device.actuators:
                    if actuator.actuator_type.name == 'Vibrate':
                        vibrating_devices.append(device)
                        break
        
        if len(vibrating_devices) < 2:
            print("❌ 需要至少2個振動設備")
            return
        
        print(f"👥 控制 {len(vibrating_devices)} 個設備")
        
        # 同步振動
        print("🔄 同步振動...")
        for device in vibrating_devices:
            await device.scalar([{
                "Index": 0,
                "Scalar": 0.6,
                "ActuatorType": "Vibrate"
            }])
        
        await asyncio.sleep(3)
        
        # 交替振動
        print("🔄 交替振動...")
        for i in range(6):
            # 停止所有設備
            for device in vibrating_devices:
                await device.stop()
            
            # 啟動當前設備
            current_device = vibrating_devices[i % len(vibrating_devices)]
            await current_device.scalar([{
                "Index": 0,
                "Scalar": 0.7,
                "ActuatorType": "Vibrate"
            }])
            print(f"   啟動: {current_device.name}")
            await asyncio.sleep(1)
        
        # 停止所有設備
        await client.stop_all_devices()
        print("✅ 多設備控制完成")
        
    except Exception as e:
        print(f"❌ 錯誤: {e}")
    finally:
        await client.disconnect()

asyncio.run(multi_device_example())

5. 設備信息查看

import asyncio
from buttplug.client import ButtplugClient, ButtplugClientWebsocketConnector

async def device_info_example():
    client = ButtplugClient("設備信息")
    
    try:
        connector = ButtplugClientWebsocketConnector("ws://localhost:12345")
        await client.connect(connector)
        
        await client.start_scanning()
        await asyncio.sleep(3)
        await client.stop_scanning()
        
        if not client.devices:
            print("❌ 未找到設備")
            return
        
        print(f"📱 找到 {len(client.devices)} 個設備:")
        print("=" * 50)
        
        for i, device in enumerate(client.devices):
            print(f"\n設備 {i+1}: {device.name}")
            print(f"   索引: {device.index}")
            
            # 執行器信息
            if hasattr(device, 'actuators') and device.actuators:
                print(f"   執行器: {len(device.actuators)} 個")
                for j, actuator in enumerate(device.actuators):
                    print(f"     #{j}: {actuator.actuator_type.name} ({actuator.step_count} 步)")
            
            # 傳感器信息
            if hasattr(device, 'sensors') and device.sensors:
                print(f"   傳感器: {len(device.sensors)} 個")
                for j, sensor in enumerate(device.sensors):
                    print(f"     #{j}: {sensor.sensor_type.name}")
                    
                    # 嘗試讀取傳感器數據
                    try:
                        reading = await device.sensor_read(j)
                        print(f"         讀數: {reading}")
                    except Exception as e:
                        print(f"         讀取失敗: {e}")
        
    except Exception as e:
        print(f"❌ 錯誤: {e}")
    finally:
        await client.disconnect()

asyncio.run(device_info_example())

6. 傳感器監控

import asyncio
from buttplug.client import ButtplugClient, ButtplugClientWebsocketConnector

async def sensor_monitoring_example():
    client = ButtplugClient("傳感器監控")
    
    # 傳感器數據處理
    @client.sensor_reading_handler
    async def sensor_data(device, sensor_index, data):
        print(f"📊 {device.name} 傳感器 {sensor_index}: {data}")
        
        # 根據數據類型處理
        if hasattr(device, 'sensors') and sensor_index < len(device.sensors):
            sensor_type = device.sensors[sensor_index].sensor_type.name
            
            if sensor_type == "Battery" and data < 20:
                print(f"🔋 警告: {device.name} 電量低 ({data}%)")
            elif sensor_type == "Button" and data:
                print(f"🔘 {device.name} 按鈕被按下")
    
    try:
        connector = ButtplugClientWebsocketConnector("ws://localhost:12345")
        await client.connect(connector)
        
        await client.start_scanning()
        await asyncio.sleep(3)
        await client.stop_scanning()
        
        # 訂閱所有設備的傳感器
        for device in client.devices:
            if hasattr(device, 'sensors') and device.sensors:
                print(f"📡 訂閱 {device.name} 的傳感器...")
                for i, sensor in enumerate(device.sensors):
                    try:
                        await device.sensor_subscribe(i)
                        print(f"   ✅ 傳感器 {i}: {sensor.sensor_type.name}")
                    except Exception as e:
                        print(f"   ❌ 訂閱失敗: {e}")
        
        # 監控30秒
        print("🕐 監控30秒...")
        await asyncio.sleep(30)
        
    except Exception as e:
        print(f"❌ 錯誤: {e}")
    finally:
        await client.disconnect()

asyncio.run(sensor_monitoring_example())

🔧 快速參考

常用代碼片段

# 快速連接
client = ButtplugClient("應用名")
connector = ButtplugClientWebsocketConnector("ws://localhost:12345")
await client.connect(connector)

# 掃描設備
await client.start_scanning()
await asyncio.sleep(3)
await client.stop_scanning()

# 振動控制
await device.scalar([{"Index": 0, "Scalar": 0.5, "ActuatorType": "Vibrate"}])

# 停止設備
await device.stop()

# 斷開連接
await client.disconnect()

安全提醒

• 建議最大強度不超過 0.8
• 使用 try-except 處理異常
• 程序結束前務必調用 disconnect()
• 定期檢查設備電量

Claude Code 效能測試與正確性驗證完整指南

基礎指令結構

完整測試指令範例

# 在你的專案目錄下執行
claude code "請為我的網站建立完整的效能測試和正確性驗證套件，包含以下需求：

1. **專案分析**：
   - 自動掃描我的專案結構和技術棧
   - 識別 API 端點、資料庫連線、前端路由
   - 分析現有的測試配置

2. **效能測試設計**：
   - 建立負載測試腳本（使用 k6 或 Artillery）
   - 資料庫效能測試（查詢分析、索引檢查）
   - 前端效能測試（Lighthouse CI 整合）
   - API 回應時間和吞吐量測試

3. **正確性驗證**：
   - 單元測試覆蓋率檢查
   - 整合測試案例
   - API 端點功能測試
   - 資料完整性驗證

4. **測試自動化**：
   - CI/CD 整合腳本
   - 效能回歸檢測
   - 測試報告生成
   - 告警機制設置

請根據我的專案實際情況客製化測試方案。"

分階段詳細指令

階段一：專案分析和基礎設置

claude code "
分析我的專案並建立測試基礎設施：

1. **專案掃描**：
   - 掃描 package.json/requirements.txt 了解技術棧
   - 找出所有 API 路由和端點
   - 識別資料庫配置和連線
   - 檢查現有測試文件

2. **測試環境配置**：
   - 建立 Docker 測試環境
   - 配置測試資料庫
   - 設置 CI/CD 測試流程
   - 建立測試資料種子

3. **監控工具整合**：
   - 整合 Prometheus + Grafana
   - 設置應用效能監控 (APM)
   - 配置日誌聚合
   - 建立效能儀表板

輸出詳細的設置步驟和配置文件。
"

階段二：效能測試實作

claude code "
為我建立全面的效能測試套件：

1. **負載測試腳本**：
   - k6 腳本涵蓋所有關鍵 API
   - 不同負載模式（漸增、突發、持續）
   - 資料庫壓力測試
   - 併發使用者情境模擬

2. **前端效能測試**：
   - Lighthouse CI 自動化
   - Core Web Vitals 監控
   - 資源載入時間測試
   - JavaScript 效能分析

3. **資料庫效能分析**：
   - 慢查詢檢測腳本
   - 索引使用率分析
   - 查詢執行計畫檢查
   - 連線池效能測試

4. **基準測試**：
   - 建立效能基準線
   - 回歸測試比較
   - 效能趨勢分析
   - 瓶頸識別工具

包含完整的測試腳本、配置文件和執行指南。
"

階段三：正確性驗證

claude code "
建立完整的正確性驗證系統：

1. **API 測試覆蓋**：
   - 所有端點的功能測試
   - 邊界條件測試
   - 錯誤處理驗證
   - 資料驗證測試

2. **資料完整性檢查**：
   - 資料庫約束驗證
   - 資料一致性測試
   - 事務完整性檢查
   - 備份恢復測試

3. **安全性測試**：
   - 輸入驗證測試
   - 授權機制檢查
   - SQL 注入防護測試
   - XSS 防護驗證

4. **整合測試**：
   - 端到端測試場景
   - 外部服務整合測試
   - 用戶流程驗證
   - 跨瀏覽器相容性

提供完整的測試案例、斷言邏輯和驗證報告。
"

針對特定技術棧的指令

Node.js + Express + MongoDB

claude code "
針對我的 Node.js Express MongoDB 應用建立效能測試：

技術棧特定需求：
- Express 中間件效能分析
- MongoDB 查詢優化檢查
- Node.js 記憶體洩漏檢測
- 事件循環阻塞監控
- Redis 快取效能測試

請使用適合的工具：Jest, Supertest, k6, MongoDB Profiler
"

Python Django + PostgreSQL

claude code "
為我的 Django PostgreSQL 應用建立測試套件：

Django 特定測試：
- ORM 查詢優化分析
- Django Debug Toolbar 整合
- PostgreSQL EXPLAIN ANALYZE 自動化
- Celery 任務效能測試
- Django 快取框架測試

使用工具：pytest, locust, django-test-utils, pgbench
"

React + Next.js

claude code "
為我的 React Next.js 應用建立前端效能測試：

Next.js 特定測試：
- SSR/SSG 效能測試
- Image Optimization 驗證
- Bundle Size 分析
- Core Web Vitals 監控
- API Routes 效能測試

使用工具：Lighthouse CI, Next.js Bundle Analyzer, Playwright
"

持續監控和報告

claude code "
建立持續效能監控和報告系統：

1. **自動化測試排程**：
   - 每日效能基準測試
   - 部署前效能檢查
   - 週期性完整測試套件
   - 效能退化自動告警

2. **報告和可視化**：
   - 效能趨勢圖表
   - 測試結果儀表板
   - 自動化測試報告
   - Slack/Email 通知整合

3. **效能預算設定**：
   - 回應時間閾值
   - 資源使用限制
   - 錯誤率上限
   - 可用性目標

4. **測試資料管理**：
   - 測試資料版本控制
   - 效能資料歸檔
   - 測試環境管理
   - 資料清理自動化
"

最佳實務指令技巧

✅ 具體化需求（好的指令）

claude code "建立 k6 負載測試，測試我的購物車 API，模擬 1000 併發用戶，包含商品搜尋、加入購物車、結帳流程，測試 10 分鐘"

❌ 模糊指令（避免使用）

claude code "幫我做效能測試"

✅ 提供專案上下文

claude code "
專案背景：電商網站，日活 10萬用戶
技術棧：React + Node.js + PostgreSQL + Redis
關鍵功能：商品搜尋、購物車、支付、用戶管理
目前痛點：高峰時段回應慢、資料庫查詢多

請建立針對性的效能測試和優化建議
"

✅ 分階段執行策略

# 第一步：分析
claude code "先分析我的專案結構，識別效能測試的關鍵點"

# 第二步：前端測試（基於第一步結果）
claude code "基於剛才的分析，建立前端效能測試，重點關注 [具體發現的問題]"

# 第三步：後端測試
claude code "建立後端 API 負載測試，特別測試 [識別出的瓶頸 API]"

測試結果分析和優化

結果驗證指令

claude code "
分析剛才的測試結果並提供優化建議：

1. **結果分析**：
   - 識別效能瓶頸
   - 分析錯誤模式
   - 比較基準線差異
   - 計算改善優先級

2. **優化建議**：
   - 具體的程式碼改善
   - 資料庫查詢優化
   - 架構調整建議
   - 基礎設施改善

3. **實作優化**：
   - 自動實施可自動化的優化
   - 產生優化後的測試腳本
   - 建立 A/B 測試比較
   - 更新效能監控配置
"

完整測試流程檢查清單

測試前準備

• 確定測試目標和成功標準
• 準備測試環境（接近生產環境）
• 設置監控和日誌系統
• 準備測試資料集

執行測試階段

• 基準效能測試
• 負載和壓力測試
• 功能正確性驗證
• 安全性測試
• 跨瀏覽器/設備測試

測試後分析

• 分析測試結果和瓶頸
• 實施優化措施
• 驗證優化效果
• 更新測試基準線
• 建立持續監控

常用測試工具整合指令

效能測試工具

claude code "整合以下效能測試工具到我的專案：
- k6 用於 API 負載測試
- Lighthouse CI 用於前端效能
- Artillery 用於複雜場景測試
- Grafana 用於監控視覺化
建立統一的測試執行腳本和報告"

正確性驗證工具

claude code "設置完整的測試框架：
- 單元測試框架 (Jest/pytest)
- API 測試 (Supertest/pytest)
- E2E 測試 (Playwright/Cypress)
- 資料庫測試工具
建立完整的 CI/CD 測試流程"

進階應用場景

微服務架構測試

claude code "
為我的微服務架構建立分散式效能測試：

服務包含：
- API Gateway
- 用戶服務
- 商品服務
- 訂單服務
- 支付服務

測試需求：
- 服務間通訊效能
- 服務降級測試
- 分散式事務測試
- 服務發現效能
- 負載均衡效果驗證
"

資料庫效能深度分析

claude code "
建立深度資料庫效能分析：

1. 查詢效能分析：
   - 慢查詢自動檢測
   - 執行計畫分析
   - 索引使用率統計

2. 容量規劃：
   - 資料增長趨勢預測
   - 效能瓶頸預警
   - 擴容建議

3. 優化建議：
   - 自動生成索引建議
   - 查詢重構建議
   - 架構優化方案
"

這份指南涵蓋了使用 Claude Code 進行全面效能測試的各個層面，你可以根據自己的專案需求選擇適合的指令模板。

GitHub 資源收集大全 🚀

整理最全面的 GitHub 資源收集網站、開發者學習平台和工具，幫助開發者發現優質開源項目，提升編程技能。

目錄

• 綜合型收集平台
• 專題型收集網站
• 導航型平台
• 學習資源平台
• 工具與統計平台
• 社區與論壇
• 特定領域資源
• 企業級資源
• 使用指南

綜合型收集平台

HelloGitHub ⭐⭐⭐⭐⭐

• 網站: https://hellogithub.com
• GitHub: https://github.com/521xueweihan/HelloGitHub
• 特色:
  • 每月 28 號發布月刊
  • 專注入門級開源項目
  • 提供中文講解和教程
• 內容類型: 月刊、熱點速遞、講解系列
• 適合人群: 初學者、中文開發者

GitHubDaily

• GitHub: https://github.com/GitHubDaily/GitHubDaily
• 特色:
  • 日更精選項目
  • 累積分享 8000+ 開源項目
  • 多平台同步（公眾號、微博、知乎、Twitter）
• 內容類型: 每日精選、技術資料、開發工具
• 適合人群: 所有開發者

Awesome 系列

• Awesome Lists: https://github.com/sindresorhus/awesome
• Awesome-GitHub-Repo: https://github.com/Wechat-ggGitHub/Awesome-GitHub-Repo
• Awesome-Repository: https://github.com/TommyMerlin/Awesome-Repository
• 特色: 按主題和技術棧分類的精選清單
• 適合人群: 需要特定領域資源的開發者

專題型收集網站

GitHub 中文排行榜

• GitHub: https://github.com/GrowingGit/GitHub-Chinese-Top-Charts
• 特色:
  • 專注中文開源項目
  • 每日自動更新排行
  • 按語言分類統計
• 更新頻率: 每日更新

GitHub Trending

• 官方地址: https://github.com/trending
• 特色:
  • GitHub 官方熱門項目
  • 支持按語言和時間篩選
  • 實時更新
• 適合人群: 關注技術趨勢的開發者

Best of JS

• 網站: https://bestofjs.org
• 特色:
  • JavaScript 生態系統專門
  • 詳細的項目對比
  • Star 趨勢圖表
• 適合人群: 前端開發者

Made With ML

• 網站: https://madewithml.com
• 特色:
  • 機器學習項目專門
  • 包含教程和實戰項目
  • 分級難度標記
• 適合人群: AI/ML 開發者

導航型平台

開發者導航網站

Dev Sites

• GitHub: https://github.com/sdmg15/Best-websites-a-programmer-should-visit
• 內容: 程序員必訪網站列表

程序員導航

• GitHub: https://github.com/geekape/geek-navigation
• 特色: 中文開發者導航站

易導航 (yinav)

• GitHub: https://github.com/chenbimo/yinav
• 特色: 開源免費的網站導航項目

Awesome-navigation

• GitHub: https://github.com/eryajf/awesome-navigation
• 特色: 優秀導航項目收集

技術棧專門導航

• 前端導航: https://github.com/jondot/awesome-react-native
• 後端導航: https://github.com/awesome-selfhosted/awesome-selfhosted
• DevOps導航: https://github.com/awesome-soft/awesome-devops

學習資源平台

免費學習資源

freeCodeCamp

• GitHub: https://github.com/freeCodeCamp/freeCodeCamp
• 特色:
  • 完整的編程課程
  • 實戰項目練習
  • 認證證書
• 語言: 英文為主，有中文版

The Odin Project

• GitHub: https://github.com/TheOdinProject/theodinproject
• 特色:
  • 全棧開發課程
  • 項目驅動學習
  • 社區支持
• 語言: 英文

MDN Web Docs

• 網站: https://developer.mozilla.org/zh-TW/
• 特色:
  • Web 開發權威文檔
  • 多語言支持
  • 互動式示例
• 適合人群: Web 開發者

編程書籍資源

Free Programming Books

• GitHub: https://github.com/EbookFoundation/free-programming-books
• 內容: 多語言免費編程書籍列表
• 數量: 3000+ 書籍

中文編程書籍

• GitHub: https://github.com/justjavac/free-programming-books-zh_CN
• 內容: 免費中文編程書籍索引
• 特色: 按語言和主題分類

技術書籍推薦

• GitHub: https://github.com/doocs/technical-books
• 內容: 優質技術書籍推薦
• 特色: 包含書評和推薦理由

實戰項目集合

Build Your Own X

• GitHub: https://github.com/codecrafters-io/build-your-own-x
• 內容:
  • 從零構建各種項目
  • 深入理解底層原理
  • 包含詳細教程
• 項目類型: 數據庫、編譯器、操作系統等

Project Based Learning

• GitHub: https://github.com/practical-tutorials/project-based-learning
• 內容:
  • 按語言分類的項目教程
  • 循序漸進的學習路徑
  • 實戰為主
• 覆蓋語言: 20+ 編程語言

RealWorld

• GitHub: https://github.com/gothinkster/realworld
• 內容:
  • 全棧應用示例
  • 多種技術棧實現
  • 真實場景應用
• 適合人群: 全棧開發者

工具與統計平台

GitHub 分析工具

GitHub Stats

• 網站: https://github-readme-stats.vercel.app
• 功能: 生成 GitHub 統計卡片
• 用途: README 美化

GitStar Ranking

• 網站: https://gitstar-ranking.com
• 功能:
  • 用戶和組織排名
  • 按國家/語言統計
  • Star 歷史追蹤

GitHub Profile Summary

• 網站: https://profile-summary-for-github.com
• 功能: 生成個人 GitHub 總結報告

Metrics

• GitHub: https://github.com/lowlighter/metrics
• 功能:
  • 高度可定制的統計圖表
  • 支持多種模板
  • 自動更新

項目質量評估

Shields.io

• 網站: https://shields.io
• 功能:
  • 生成項目徽章
  • 動態數據顯示
  • 自定義樣式

Libraries.io

• 網站: https://libraries.io
• 功能:
  • 依賴追蹤
  • 版本監控
  • 安全警告

Snyk

• 網站: https://snyk.io
• 功能:
  • 安全漏洞檢測
  • 依賴分析
  • 自動修復建議

社區與論壇

國際社區

Dev.to

• 網站: https://dev.to
• 特色:
  • 開發者博客平台
  • 技術文章分享
  • 活躍的討論社區

Stack Overflow

• 網站: https://stackoverflow.com
• 特色:
  • 最大的技術問答社區
  • 問題解決方案庫
  • 聲望系統

Reddit Programming

• 網站: https://www.reddit.com/r/programming/
• 特色:
  • 技術討論
  • 項目分享
  • 行業動態

中文社區

V2EX

• 網站: https://www.v2ex.com
• 特色:
  • 技術創意社區
  • 職場討論
  • 項目展示

掘金

• 網站: https://juejin.cn
• 特色:
  • 技術文章平台
  • 開發者社區
  • 線上活動

SegmentFault 思否

• 網站: https://segmentfault.com
• 特色:
  • 技術問答
  • 專欄文章
  • 技術活動

CodeLove 論壇

• 網站: https://codelove.tw
• 特色:
  • 台灣開發者社區
  • 技術分享
  • 項目討論

特定領域資源

前端資源

Frontend Masters

• GitHub: https://github.com/FrontendMasters
• 內容: 前端進階課程和資源

30 seconds of code

• GitHub: https://github.com/30-seconds/30-seconds-of-code
• 內容:
  • 簡短代碼片段
  • 常用功能實現
  • 多語言版本

You Don't Need

• GitHub: https://github.com/you-dont-need/You-Dont-Need-JavaScript
• 內容: CSS 解決方案替代 JavaScript

後端資源

System Design Primer

• GitHub: https://github.com/donnemartin/system-design-primer
• 內容:
  • 系統設計指南
  • 架構模式
  • 面試準備

Awesome Backend

• GitHub: https://github.com/zhashkevych/awesome-backend
• 內容: 後端開發資源集合

Awesome Microservices

• GitHub: https://github.com/mfornos/awesome-microservices
• 內容: 微服務架構資源

移動開發

Awesome iOS

• GitHub: https://github.com/vsouza/awesome-ios
• 內容: iOS 開發資源大全

Awesome Android

• GitHub: https://github.com/JStumpp/awesome-android
• 內容: Android 開發資源集合

Flutter Awesome

• GitHub: https://github.com/Solido/awesome-flutter
• 內容: Flutter 資源和插件

DevOps & 雲原生

Awesome Kubernetes

• GitHub: https://github.com/ramitsurana/awesome-kubernetes
• 內容: Kubernetes 資源集合

Awesome Docker

• GitHub: https://github.com/veggiemonk/awesome-docker
• 內容: Docker 資源和工具

Awesome CI/CD

• GitHub: https://github.com/cicdops/awesome-ciandcd
• 內容: 持續集成和部署資源

數據科學 & AI

Awesome Machine Learning

• GitHub: https://github.com/josephmisiti/awesome-machine-learning
• 內容: 機器學習框架和庫

Awesome Deep Learning

• GitHub: https://github.com/ChristosChristofidis/awesome-deep-learning
• 內容: 深度學習資源

Awesome Data Science

• GitHub: https://github.com/academic/awesome-datascience
• 內容: 數據科學學習資源

企業級資源

大廠開源項目

國際巨頭

• Google: https://github.com/google
• Facebook (Meta): https://github.com/facebook
• Microsoft: https://github.com/microsoft
• Amazon: https://github.com/amzn
• Apple: https://github.com/apple

中國大廠

• Alibaba: https://github.com/alibaba
• Tencent: https://github.com/tencent
• Baidu: https://github.com/baidu
• ByteDance: https://github.com/bytedance
• Huawei: https://github.com/huawei

技術團隊資源

工程博客

• Airbnb Engineering: https://github.com/airbnb
• Netflix Tech Blog: https://github.com/Netflix
• Uber Engineering: https://github.com/uber
• LinkedIn Engineering: https://github.com/linkedin
• Spotify: https://github.com/spotify

使用指南

🌱 初學者路徑

1. 入門階段

   • 從 HelloGitHub 月刊開始，了解有趣項目
   • 使用 freeCodeCamp 系統學習編程基礎
   • 參考 Free Programming Books 找學習資料

2. 實踐階段

   • 參考 Project Based Learning 進行項目練習
   • 在 Dev.to 或掘金分享學習心得
   • 使用 30 seconds of code 學習代碼片段

3. 進階階段

   • 研究 Build Your Own X 深入理解原理
   • 參與開源項目貢獻
   • 建立自己的 GitHub 項目

🚀 進階開發者

1. 技術追蹤

   • 每日查看 GitHub Trending
   • 訂閱 GitHubDaily 獲取精選項目
   • 關注特定領域的 Awesome 列表

2. 深度學習

   • 研究 System Design Primer
   • 學習大廠開源項目
   • 參與技術社區討論

3. 個人品牌

   • 使用 GitHub Stats 展示個人數據
   • 在技術社區發表文章
   • 維護高質量開源項目

👥 團隊領導

1. 技術選型

   • 參考 Awesome 系列進行技術評估
   • 使用 Libraries.io 檢查依賴健康度
   • 通過 Snyk 確保項目安全

2. 團隊成長

   • 建立內部技術分享機制
   • 鼓勵團隊參與開源
   • 學習大廠最佳實踐

3. 項目管理

   • 使用 Shields.io 規範項目文檔
   • 建立 CI/CD 流程
   • 定期技術債務評估

📊 效率提升技巧

1. 信息獲取

   • 設置 GitHub Watch 關注重要項目
   • 使用 RSS 訂閱技術博客
   • 加入相關技術群組

2. 學習方法

   • 理論與實踐結合
   • 定期總結分享
   • 建立知識體系

3. 時間管理

   • 每天固定時間瀏覽技術資訊
   • 週末深入研究感興趣的項目
   • 定期回顧和整理收藏

貢獻指南

歡迎提交 Pull Request 來完善這份清單！提交前請確保：

• 資源真實有效
• 描述準確清晰
• 符合分類規範
• 避免重複內容

許可證

本文檔採用 CC BY 4.0 許可證。

最後更新時間: 2025年1月

⭐ 如果這份清單對您有幫助，請給個 Star 支持一下！

ClaudeNightsWatch - 自主任務執行系統

基於 Claude CLI 的智能自主任務執行系統，可監控使用時間窗口並自動執行預定義任務。

🌟 核心功能

• 自主執行 - 無需手動干預自動執行任務
• 任務流程 - 使用簡單的 markdown 文件定義任務
• 安全規則 - 透過 rules.md 配置安全約束
• 智能定時 - 使用 ccusage 獲得準確的時間監控
• 預定開始 - 可配置特定時間開始執行
• 全面記錄 - 追蹤所有活動和執行歷史

📋 前置要求

必需組件

• Claude CLI - 已安裝並配置

可選組件

• ccusage - 提供精確時間監控

  npm install -g ccusage
  

🚀 快速開始

1. 安裝設置

# 克隆存儲庫
git clone https://github.com/aniketkarne/ClaudeNightsWatch.git
cd ClaudeNightsWatch

# 使腳本可執行
chmod +x *.sh

# 運行互動式設置
./setup-nights-watch.sh

2. 創建配置文件

task.md - 任務定義

# 日常開發任務
1. 對所有源文件運行 linting
2. 更新依賴項到最新版本
3. 運行測試套件
4. 生成覆蓋率報告
5. 創建變更摘要

rules.md - 安全規則

# 安全規則
- 在不備份的情況下永不刪除文件
- 只在項目目錄內工作
- 始終為變更創建 feature 分支
- 永不提交敏感信息

🎮 基本使用

啟動系統

# 立即啟動
./claude-nights-watch-manager.sh start

# 指定時間啟動
./claude-nights-watch-manager.sh start --at "09:00"
./claude-nights-watch-manager.sh start --at "2025-01-28 14:30"

管理命令

# 停止守護程序
./claude-nights-watch-manager.sh stop

# 檢查狀態
./claude-nights-watch-manager.sh status

# 重啟守護程序
./claude-nights-watch-manager.sh restart

# 查看任務和規則
./claude-nights-watch-manager.sh task

日誌管理

# 查看日誌
./claude-nights-watch-manager.sh logs

# 實時跟隨日誌
./claude-nights-watch-manager.sh logs -f

# 互動式日誌查看器
./view-logs.sh

⚙️ 系統架構

工作原理

1. 監控階段 - 持續監控 Claude 使用時間窗口
2. 定時階段 - 接近 5 小時限制時準備執行
3. 任務準備 - 讀取並組合 rules.md 和 task.md
4. 自主執行 - 使用 claude --dangerously-skip-permissions 執行
5. 記錄階段 - 完整記錄所有活動

時間檢測機制

自適應檢查間隔

🔄 多工任務管理

Claude 多會話能力

• ✅ 技術上可行 - 一個帳號可同時多個 CLI 會話
• ⚠️ 共享配額 - 所有會話共用 5 小時使用限制
• 🎯 建議策略 - 智慧規劃勝過暴力並行

多工執行策略

策略一：多目錄管理（推薦）

~/claude-tasks/
├── project-a/          # 專案 A 獨立環境
│   ├── task.md
│   ├── rules.md
│   └── claude-nights-watch-*
├── project-b/          # 專案 B 獨立環境
│   ├── task.md
│   ├── rules.md
│   └── claude-nights-watch-*
└── project-c/          # 專案 C 獨立環境
    ├── task.md
    ├── rules.md
    └── claude-nights-watch-*

策略二：時間分段執行

# 早上執行專案 A
./claude-nights-watch-manager.sh start --at "09:00"

# 中午執行專案 B
./claude-nights-watch-manager.sh start --at "13:00"

# 下午執行專案 C
./claude-nights-watch-manager.sh start --at "17:00"

策略三：tmux 並行監控

# 創建 tmux 會話
tmux new-session -d -s claude-tasks

# 建立多個視窗
tmux new-window -t claude-tasks:1 -n 'project-a'
tmux new-window -t claude-tasks:2 -n 'project-b'
tmux new-window -t claude-tasks:3 -n 'project-c'

# 在各視窗啟動任務
tmux send-keys -t claude-tasks:1 'cd ~/claude-tasks/project-a && ./claude-nights-watch-manager.sh start' Enter
tmux send-keys -t claude-tasks:2 'cd ~/claude-tasks/project-b && ./claude-nights-watch-manager.sh start' Enter
tmux send-keys -t claude-tasks:3 'cd ~/claude-tasks/project-c && ./claude-nights-watch-manager.sh start' Enter

方案選擇建議

Pro 用戶（$20/月）

• 🎯 時間分段執行
• 🎯 任務整合到單一 task.md
• 🎯 重點單一專案深度工作

Max 5x 用戶（$100/月）

• 🎯 2-3 個並行會話
• 🎯 tmux 分割管理
• 🎯 監控配額使用

Max 20x 用戶（$200/月）

• 🎯 真正多專案並行
• 🎯 5+ 個同時會話
• 🎯 適合大型團隊

⚠️ 安全注意事項

重要提醒

此工具使用 --dangerously-skip-permissions 標誌，將不經確認執行任務

安全建議

• ✅ 在設置前手動測試所有任務
• ✅ 使用完整的 rules.md 防止破壞性操作
• ✅ 從簡單任務開始，逐步增加複雜性
• ✅ 定期監控日誌確保正確執行
• ✅ 保留重要數據備份
• ✅ 在隔離環境中運行

推薦安全規則

• 🔒 限制文件系統訪問到項目目錄
• 🚫 禁止刪除命令
• 🛡️ 防止系統修改
• 🌐 限制網路訪問
• 📊 設置資源限制

🐛 疑難排解

檢查清單

1. Claude CLI 安裝 - which claude
2. 配置文件存在 - 驗證 task.md 存在
3. 查看日誌 - ./claude-nights-watch-manager.sh logs
4. 使用量檢查 - ccusage blocks
5. 時間設置 - 檢查預定開始時間
6. 文件內容 - 確保 task.md 不為空
7. 精確監控 - 安裝 ccusage 提高準確性
8. 系統時間 - 檢查時間是否正確

📁 項目結構

claude-nights-watch/
├── claude-nights-watch-daemon.sh      # 核心守護程序
├── claude-nights-watch-manager.sh     # 管理界面
├── setup-nights-watch.sh              # 設置腳本
├── view-logs.sh                        # 日誌查看器
├── logs/                               # 日誌存儲
├── examples/                           # 示例文件
│   ├── task.example.md
│   └── rules.example.md
└── test/                              # 測試腳本
    ├── test-simple.sh
    ├── test-task-simple.md
    └── test-rules-simple.md

🧪 測試與驗證

# 進入測試目錄
cd test

# 運行簡單測試
./test-simple.sh

# 測試即時執行
./test-immediate-execution.sh

🤝 貢獻指南

1. Fork 存儲庫
2. 創建 feature 分支
3. 遵循現有代碼風格
4. 優先考慮安全性
5. 更新相關文檔
6. 提供使用示例
7. 確保測試通過
8. 提交 Pull Request

📄 授權資訊

• 授權 - MIT License
• 創建者 - Aniket Karne
• 基於 - CCAutoRenew 專案

記住：強大的自動化伴隨重大責任。啟用自主執行前，請務必仔細檢查任務和規則！🚨

ClaudeNightsWatch 完整設定指南

概述

ClaudeNightsWatch 是一個自動化守護程序，會在 Claude CLI 使用時間窗口結束前自動執行預定義的任務。

設定步驟

步驟 1：執行互動式設定腳本

執行設定腳本：

./setup-nights-watch.sh

此腳本會：

1. 檢查必要條件

   • 確認 Claude CLI 已安裝
   • 檢查 ccusage（可選，用於精確時間追蹤）

2. 引導設定流程

   • 提示建立任務檔案
   • 設定安全規則
   • 配置守護程序選項

步驟 2：建立任務檔案 (task.md)

範例任務檔案：

# 自動化開發任務

## 目標：
1. 執行程式碼品質檢查
2. 更新專案文件
3. 執行測試套件

## 具體任務：
- 在 src/ 目錄執行 linting
- 修正發現的問題
- 執行所有單元測試
- 產生測試覆蓋率報告
- 更新 CHANGELOG.md

步驟 3：建立安全規則 (rules.md)

預設安全規則包含：

• 禁止破壞性命令：不執行 rm -rf、不刪除系統檔案
• 保護敏感資料：不暴露密碼、API keys
• 限制工作範圍：只在專案目錄內工作
• Git 安全：不強制推送到主分支、建立功能分支
• 最佳實踐：測試變更、備份資料、記錄修改

步驟 4：啟動守護程序

立即啟動：

./claude-nights-watch-manager.sh start

排程啟動：

# 今天 09:00 啟動
./claude-nights-watch-manager.sh start --at "09:00"

# 特定日期時間啟動
./claude-nights-watch-manager.sh start --at "2025-01-28 14:30"

步驟 5：驗證運作狀態

檢查系統狀態：

# 檢查守護程序狀態
./claude-nights-watch-manager.sh status

# 查看執行日誌
./claude-nights-watch-manager.sh logs

# 互動式日誌檢視器
./view-logs.sh

# 查看當前任務設定
./claude-nights-watch-manager.sh task

運作原理

核心機制

1. 監控時間：持續監控 Claude 使用時間窗口
2. 自動觸發：在 5 小時限制前 2 分鐘準備執行
3. 執行任務：結合 rules.md + task.md，使用 claude --dangerously-skip-permissions 自動執行
4. 完整記錄：所有活動記錄在 logs/ 目錄

時間檢查邏輯

• 有 ccusage：從 API 取得準確剩餘時間
• 無 ccusage：使用時間戳記檢查
• 自適應檢查間隔：
  • 剩餘 30+ 分鐘：每 10 分鐘檢查
  • 剩餘 5-30 分鐘：每 2 分鐘檢查
  • 剩餘 <5 分鐘：每 30 秒檢查

任務完成狀態

• ✅ 檢查並執行 setup-nights-watch.sh 互動式設定
• ✅ 建立 task.md 任務檔案
• ✅ 建立 rules.md 安全規則檔案
• ✅ 啟動守護程序
• ✅ 驗證設定是否正常運作

⚠️ 重要安全提醒

此工具會自動執行任務且無需確認，務必：

1. 事前測試：先手動測試所有任務
2. 完整規則：設定詳細的安全規則
3. 定期監控：檢查執行日誌
4. 資料備份：備份重要資料

常用管理命令

# 停止守護程序
./claude-nights-watch-manager.sh stop

# 重新啟動
./claude-nights-watch-manager.sh restart

# 更新任務
./claude-nights-watch-manager.sh update-task

# 清理日誌
./claude-nights-watch-manager.sh clean-logs

設定完成！ ClaudeNightsWatch 現在會在適當時機自動執行您的任務。

Cross Compiler 與 LLVM vs GCC 完整解析

📋 目錄

1. 常見誤解與正確理解
2. Android 編譯流程圖解
3. 編譯過程比喻
4. 實際操作差異
5. 為什麼 Rust 比較簡單
6. Android NDK 的角色
7. 效能比較
8. LLVM vs GCC 架構比較
9. 編譯流程詳細對比
10. 前端 vs 後端詳細比較
11. LLVM IR：統一語言的力量
12. 優缺點比較
13. 為什麼現代編譯器都選 LLVM
14. 實際應用場景
15. 總結

🚫 常見誤解與正確理解

誤解 1：「Cross Compiler 就是把程式碼丟到另一台機器編譯」

❌ 錯誤想法：

我的電腦 → 把程式碼傳到 Android 手機 → 在手機上編譯

✅ 正確理解：

我的電腦 (x86) → 用特殊編譯器 → 產生 ARM 程式 → 丟到手機執行

白話： 就像在台灣的工廠，用特殊機器做出適合美國規格的產品，直接運到美國販售。

誤解 2：「Rust 編譯器就是 GCC 的包裝」

❌ 錯誤想法：

Rust 程式碼 → 翻譯成 C 程式碼 → 用 GCC 編譯

✅ 正確理解：

Rust 程式碼 → Rust 編譯器 → LLVM IR → LLVM 後端 → 機器碼

白話： Rust 有自己的「翻譯員」(編譯器)，最後都交給同一個「印刷廠」(LLVM) 印成各種語言的書。

📱 Android 編譯流程圖解

傳統 GCC 方式 (已淘汰)

你的電腦 (Ubuntu/Windows)
├── arm-linux-gnueabihf-gcc  ← 專門的 ARM 編譯器
├── ARM 版本的 libc          ← 要自己準備 ARM 版本的庫
├── ARM 版本的其他庫
└── 編譯出來 → ARM 執行檔 → 放到 Android 手機

現代 Rust + NDK 方式

你的電腦
├── Rust 編譯器 (rustc)
├── Android NDK (Google 提供)
│   ├── Clang 編譯器
│   ├── Android 系統庫 (libc, libm...)
│   └── 各種 ARM/x86 工具
└── 一個指令就搞定 → ARM 執行檔 → 手機

🏭 編譯過程比喻

GCC 編譯：像傳統工廠

原料 (C程式碼)
    ↓
特殊機器 (arm-gcc) - 需要手動調整很多設定
    ↓  
半成品 (組合語言)
    ↓
包裝機器 (linker) - 要手動準備包裝材料
    ↓
最終產品 (ARM執行檔)

Rust 編譯：像自動化工廠

原料 (Rust程式碼)
    ↓
智能機器 (rustc) - 自動選擇最適合的生產線
    ↓
統一加工廠 (LLVM) - 什麼產品都會做
    ↓
自動包裝 (LLVM linker) - 自動準備所需材料
    ↓
最終產品 (ARM執行檔)

🔧 實際操作差異

GCC 需要手動設定一大堆

# 要設定一堆環境變數
export CC=arm-linux-gnueabihf-gcc
export CXX=arm-linux-gnueabihf-g++
export AR=arm-linux-gnueabihf-ar
export STRIP=arm-linux-gnueabihf-strip
export SYSROOT=/usr/arm-linux-gnueabihf

# 編譯時要指定一堆參數
arm-linux-gnueabihf-gcc \
  --sysroot=$SYSROOT \
  -march=armv7-a \
  -mfloat-abi=hard \
  -mfpu=neon \
  -o myapp myapp.c

Rust 超簡單

# 一次性設定
rustup target add aarch64-linux-android

# 編譯就這樣
cargo build --target aarch64-linux-android

💡 為什麼 Rust 比較簡單？

1. 統一後端

GCC 時代： 每個平台都要不同的編譯器

x86 → gcc
ARM → arm-gcc  
MIPS → mips-gcc
每個都要分別安裝和設定

LLVM 時代： 一個後端支援所有平台

任何語言 → LLVM IR → 自動產生各平台程式碼

2. 包裝管理

GCC： 你要自己管理所有相依性

我需要 ARM 版本的：
- libc
- libstdc++
- libm
- 其他一堆庫...
全部要自己找、自己裝、自己連結

Rust： 自動處理相依性

Rust 編譯器：「你要編譯到 Android？好的，我自動：
- 下載需要的庫
- 設定正確的連結方式
- 處理 ABI 相容性
- 完成！」

🎯 Android NDK 的角色

NDK 就像「工具箱」

Android NDK
├── 📱 支援所有 Android 手機架構
│   ├── arm64-v8a (新手機)
│   ├── armeabi-v7a (舊手機)
│   ├── x86_64 (模擬器)
│   └── x86 (舊模擬器)
├── 🔧 編譯工具 (Clang/LLVM)
├── 📚 Android 系統函數庫
└── 🎯 自動處理版本相容性

白話： NDK 就像一個萬能工具箱，裡面有各種螺絲起子、扳手，而且會自動選擇最適合你手機的工具。

⚡ 效能比較

編譯速度

• GCC： 較慢，特別是大型專案
• LLVM： 現代優化，平行編譯更好

執行效能

• GCC： 傳統優化，對某些 CPU 特殊指令支援好
• LLVM： 跨平台優化較一致，新 CPU 支援更快

維護難度

• GCC Cross： 🔴 困難 - 要懂很多底層細節
• Rust + LLVM： 🟢 簡單 - 大多時候自動處理

🏗️ LLVM vs GCC 架構比較

GCC 傳統架構 (緊耦合)

C/C++/Fortran 程式碼
         ↓
┌─────────────────────────────────────┐
│           GCC 編譯器                │
│  ┌───────────┬──────────┬─────────┐ │
│  │   前端    │   中端   │  後端   │ │
│  │ (Parser)  │  (優化)  │(代碼生成)│ │
│  │           │          │         │ │
│  │ C Frontend│          │ x86 後端│ │
│  │ C++Frontend│ GCC IR  │ARM 後端 │ │
│  │Fort Frontend│        │MIPS後端 │ │
│  └───────────┴──────────┴─────────┘ │
└─────────────────────────────────────┘
         ↓
    機器碼 (x86/ARM/MIPS)

LLVM 模組化架構 (鬆耦合)

C/C++/Rust/Swift 程式碼
         ↓
┌─────────────────────────────────────┐
│         多種前端 (可插拔)            │
│  ┌─────────┬─────────┬─────────┐   │
│  │ Clang   │ Rustc   │ Swift   │   │
│  │(C/C++)  │ (Rust)  │ (Swift) │   │
│  └─────────┴─────────┴─────────┘   │
└─────────────────────────────────────┘
         ↓
┌─────────────────────────────────────┐
│           LLVM IR                   │
│      (統一中間表示法)               │
│  %1 = add i32 %a, %b              │
│  %2 = mul i32 %1, %c              │
└─────────────────────────────────────┘
         ↓
┌─────────────────────────────────────┐
│       LLVM 後端 (可插拔)            │
│  ┌─────────┬─────────┬─────────┐   │
│  │ x86     │ ARM     │ RISC-V  │   │
│  │ 後端    │ 後端    │ 後端    │   │
│  └─────────┴─────────┴─────────┘   │
└─────────────────────────────────────┘
         ↓
    機器碼 (x86/ARM/RISC-V)

🔄 編譯流程詳細對比

GCC 編譯流程 (一體式)

原始程式碼
    ↓
┌─────────────┐
│   預處理器   │ (.i/.ii)
│  (cpp)      │
└─────────────┘
    ↓
┌─────────────┐
│  語法分析   │ (AST)
│ (Frontend)  │
└─────────────┘
    ↓
┌─────────────┐
│  GCC IR     │ (GIMPLE/RTL)
│ (內部表示)   │
└─────────────┘
    ↓
┌─────────────┐
│  優化階段   │
│ (Middle-end)│
└─────────────┘
    ↓
┌─────────────┐
│  代碼生成   │ (.s)
│ (Backend)   │
└─────────────┘
    ↓
┌─────────────┐
│  組譯器     │ (.o)
│   (as)     │
└─────────────┘
    ↓
┌─────────────┐
│  連結器     │ (executable)
│   (ld)     │
└─────────────┘

LLVM 編譯流程 (模組式)

原始程式碼 (C/Rust/Swift)
    ↓
┌─────────────┐
│各語言前端   │
│Clang/Rustc  │ → AST
│/SwiftC      │
└─────────────┘
    ↓
┌─────────────┐
│ LLVM IR     │ ← 統一格式！
│ (中間表示)   │   所有語言都變這樣
│ %1 = add... │
└─────────────┘
    ↓
┌─────────────┐
│ LLVM 優化   │
│(Pass 系統)  │ ← 共用優化器
└─────────────┘
    ↓
┌─────────────┐
│ LLVM 後端   │
│(目標產生)   │ ← 共用後端
└─────────────┘
    ↓
┌─────────────┐
│ 機器碼      │
│ (x86/ARM)   │
└─────────────┘

🧩 前端 vs 後端詳細比較

GCC：一對多的緊密結合

前端 (語言特定)        後端 (架構特定)
┌──────────────┐    ┌──────────────┐
│ C Frontend   │────┤              │
├──────────────┤    │   x86 後端   │
│ C++ Frontend │────┤              │
├──────────────┤    └──────────────┘
│ Fort Frontend│    ┌──────────────┐
├──────────────┤    │              │
│ Ada Frontend │────┤   ARM 後端   │
├──────────────┤    │              │
│ Go Frontend  │────┤              │
└──────────────┘    └──────────────┘
                    ┌──────────────┐
                    │              │
                    │  MIPS 後端   │
                    │              │
                    └──────────────┘

問題：每增加一個語言 → 要為每個架構寫適配
     每增加一個架構 → 要為每個語言寫適配
     N × M 的複雜度！

LLVM：多對一對多的分離設計

前端 (語言特定)     中間層        後端 (架構特定)
┌──────────────┐              ┌──────────────┐
│    Clang     │              │              │
│   (C/C++)    │────┐         │   x86 後端   │
└──────────────┘    │         │              │
┌──────────────┐    │         └──────────────┘
│    Rustc     │    │ LLVM IR ┌──────────────┐
│   (Rust)     │────┼────────→│              │
└──────────────┘    │         │   ARM 後端   │
┌──────────────┐    │         │              │
│   SwiftC     │    │         └──────────────┘
│   (Swift)    │────┘         ┌──────────────┐
└──────────────┘              │              │
                              │  RISC-V 後端 │
                              │              │
                              └──────────────┘

優勢：增加新語言 → 只需實現到 LLVM IR
     增加新架構 → 只需從 LLVM IR 實現
     N + M 的複雜度！

💡 LLVM IR：統一語言的力量

LLVM IR 範例

; 簡單的加法函數
define i32 @add(i32 %a, i32 %b) {
entry:
  %result = add i32 %a, %b
  ret i32 %result
}

; 不管原始語言是 C、Rust 還是 Swift
; 最終都變成這樣的統一格式

各語言到 LLVM IR 的轉換

C 程式碼:           Rust 程式碼:        Swift 程式碼:
int add(int a,      fn add(a: i32,      func add(_ a: Int32,
        int b) {           b: i32)             _ b: Int32)
  return a + b;        -> i32 {               -> Int32 {
}                      a + b               return a + b
                     }                   }

                    ↓ 全部變成 ↓

            define i32 @add(i32 %a, i32 %b) {
              %result = add i32 %a, %b
              ret i32 %result
            }

⚖️ 優缺點比較

🚀 為什麼現代編譯器都選 LLVM？

1. 開發效率

新語言開發成本：
GCC: 需要實現完整的編譯器 (100% 工作量)
LLVM: 只需實現前端 (30% 工作量)

2. 維護成本

支援 5 種語言 × 4 種架構：
GCC: 需要維護 20 個不同的組合
LLVM: 需要維護 5 個前端 + 4 個後端 = 9 個組件

3. 創新速度

新優化技術：
GCC: 需要在每個後端分別實現
LLVM: 在 LLVM IR 層面實現一次，所有語言受益

🎯 實際應用場景

GCC 仍然適合的場景

• Linux 系統編譯：深度整合，啟動快
• 嵌入式系統：資源受限，需要最小化
• 特定硬體優化：某些特殊指令集支援更好

LLVM 更適合的場景

• 新語言開發：Rust、Swift、Kotlin Native
• 跨平台開發：一套代碼多平台
• 現代 IDE 整合：更好的錯誤訊息和分析
• 研究和實驗：容易修改和擴展

📊 總結

編譯器進化史

1970s-1980s: 每種語言都有自己的編譯器
           C → cc, Pascal → pc, Fortran → f77
           
1990s-2000s: GCC 統一了多語言
           C/C++/Fortran/Ada → gcc
           
2010s-現在: LLVM 統一了多語言多後端
          C/C++/Rust/Swift/... → LLVM → x86/ARM/RISC-V/...

為什麼現在都用 LLVM？

1. 一套工具統治所有平台 - 不用學一堆不同的編譯器
2. 自動化程度高 - 減少人工設定錯誤
3. 社群支援好 - Apple、Google、Mozilla 都在用
4. 新技術支援快 - 新的 CPU 指令、新的優化技術

最重要的： 讓開發者專注在寫程式，而不是搞編譯器設定！

未來趨勢： 更多語言會選擇基於 LLVM，因為它提供了最好的「投資報酬率」- 用最少的努力獲得最廣的平台支援！

程式分析工具完整指南 - 多語言版

目錄

• C/C++ 分析工具
• Python 分析工具
• Java 分析工具
• Go 分析工具
• Rust 分析工具
• JavaScript/Node.js 分析工具
• .NET/C# 分析工具
• 跨語言通用工具
• 視覺化工具

C/C++ 分析工具

記憶體分析

Valgrind (Linux/macOS)

valgrind --leak-check=full --show-leak-kinds=all ./program
valgrind --tool=massif ./program  # heap profiling

AddressSanitizer (ASan)

g++ -fsanitize=address -g program.cpp
clang++ -fsanitize=address -g program.cpp

Memory Sanitizer (MSan)

clang++ -fsanitize=memory -fPIE -pie -g program.cpp

Dr. Memory (跨平台)

drmemory -- ./program

效能分析

perf (Linux)

perf record -g ./program
perf report
perf stat ./program

gprof

g++ -pg program.cpp -o program
./program
gprof program gmon.out > analysis.txt

Intel VTune Profiler

• CPU Hotspots
• Memory Access
• Threading Analysis
• Microarchitecture Analysis

gperftools

LD_PRELOAD=/usr/lib/libprofiler.so CPUPROFILE=prof.out ./program
google-pprof --pdf program prof.out > profile.pdf

Python 分析工具

記憶體分析

memory_profiler

# 安裝: pip install memory-profiler
# 使用裝飾器
@profile
def my_func():
    pass

# 執行
python -m memory_profiler script.py

tracemalloc (內建)

import tracemalloc
tracemalloc.start()
# ... code ...
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')

objgraph

# 視覺化物件引用
import objgraph
objgraph.show_most_common_types()
objgraph.show_refs(obj, filename='refs.png')

pympler

from pympler import tracker
tr = tracker.SummaryTracker()
tr.print_diff()

效能分析

cProfile (內建)

python -m cProfile -s cumulative script.py
python -m cProfile -o output.prof script.py

line_profiler

# 安裝: pip install line_profiler
@profile
def slow_function():
    pass

# 執行
kernprof -l -v script.py

py-spy

# 不需修改程式碼的 profiler
py-spy record -o profile.svg -- python script.py
py-spy top -- python script.py
py-spy dump --pid $PID

Pyflame (已停止維護)

pyflame -s 3600 -r 0.01 -o profile.svg $PID

Austin

austin python script.py
austin -i 100 python script.py  # 100 微秒採樣間隔

Scalene

# 高效能 CPU+GPU+記憶體 profiler
scalene script.py

Java 分析工具

記憶體分析

Eclipse Memory Analyzer (MAT)

• Heap dump 分析
• Memory leak 偵測
• Dominator tree 分析

jmap (JDK 內建)

jmap -heap $PID
jmap -dump:format=b,file=heap.bin $PID

jhat (JDK 內建)

jhat heap.bin

VisualVM

• GUI 工具
• Heap/Thread dump
• Memory/CPU profiling

效能分析

JProfiler

• 商業工具
• CPU/Memory/Thread profiling
• Database/Web 請求分析

YourKit Java Profiler

• 商業工具
• 低開銷
• 生產環境可用

Java Flight Recorder (JFR)

# JDK 11+ 免費
java -XX:StartFlightRecording=duration=60s,filename=recording.jfr MyApp
jcmd $PID JFR.start duration=60s filename=recording.jfr

async-profiler

# 低開銷的採樣 profiler
./profiler.sh -d 30 -f flamegraph.html $PID

jstack (JDK 內建)

jstack $PID > thread_dump.txt

Go 分析工具

內建 pprof

CPU Profiling

import _ "net/http/pprof"
go func() {
    log.Println(http.ListenAndServe("localhost:6060", nil))
}()

go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30
go tool pprof -http=:8080 profile.pb.gz

Memory Profiling

go tool pprof http://localhost:6060/debug/pprof/heap
go tool pprof -alloc_space profile.pb.gz

Goroutine Analysis

go tool pprof http://localhost:6060/debug/pprof/goroutine

trace

import "runtime/trace"
trace.Start(os.Stderr)
defer trace.Stop()

go tool trace trace.out

go-torch (已整合到 pprof)

go-torch -u http://localhost:6060/debug/pprof/profile

goleak

// Goroutine leak 檢測
defer goleak.VerifyNone(t)

Rust 分析工具

記憶體分析

Valgrind

cargo build --release
valgrind --leak-check=full target/release/program

heaptrack

heaptrack target/release/program
heaptrack_gui heaptrack.program.*.gz

dhat

#![allow(unused)]
fn main() {
// Rust 的 heap profiler
#[global_allocator]
static ALLOC: dhat::Alloc = dhat::Alloc;
}

效能分析

cargo-flamegraph

cargo install flamegraph
cargo flamegraph

perf + flamegraph

perf record --call-graph=dwarf target/release/program
perf script | flamegraph.pl > flame.svg

criterion

#![allow(unused)]
fn main() {
// Benchmark 框架
use criterion::{black_box, criterion_group, criterion_main, Criterion};
}

pprof-rs

#![allow(unused)]
fn main() {
// CPU/Memory profiling
use pprof::protos::Message;
}

cargo-profiling

cargo install cargo-profiling
cargo profiling callgrind
cargo profiling cachegrind

JavaScript/Node.js 分析工具

記憶體分析

Chrome DevTools

• Heap Snapshot
• Allocation Timeline
• Memory Profiler

heapdump

const heapdump = require('heapdump');
heapdump.writeSnapshot((err, filename) => {
    console.log('Heap dump written to', filename);
});

memwatch-next

const memwatch = require('memwatch-next');
memwatch.on('leak', (info) => {
    console.error('Memory leak detected:', info);
});

效能分析

Node.js 內建 profiler

node --prof app.js
node --prof-process isolate-*.log > processed.txt

clinic.js

npm install -g clinic
clinic doctor -- node app.js
clinic flame -- node app.js
clinic bubbleprof -- node app.js

0x

npm install -g 0x
0x app.js

Chrome DevTools

node --inspect app.js
node --inspect-brk app.js

.NET/C# 分析工具

記憶體分析

dotMemory (JetBrains)

• Memory snapshots
• Memory traffic 分析
• 自動 leak 偵測

PerfView

PerfView collect /MaxCollectSec:30 MyApp.exe
PerfView HeapDump MyApp.exe

Visual Studio Diagnostic Tools

• 整合在 IDE
• Memory Usage
• CPU Usage

效能分析

BenchmarkDotNet

[Benchmark]
public void MyMethod() { }

dotTrace (JetBrains)

• Performance profiler
• Timeline profiling
• SQL query 分析

Application Insights

• 生產環境監控
• 自動效能追蹤

跨語言通用工具

系統層級分析

DTrace (macOS/Solaris/BSD)

sudo dtrace -n 'syscall:::entry { @[execname] = count(); }'

SystemTap (Linux)

stap -e 'probe timer.s(1) { print("Hello\n") }'

eBPF/bpftrace (Linux)

bpftrace -e 'tracepoint:syscalls:sys_enter_* { @[comm] = count(); }'

strace/ltrace (Linux)

strace -c ./program
ltrace -c ./program

Process Monitor (Windows)

• GUI 工具
• File/Registry/Network 活動

APM (Application Performance Monitoring)

New Relic

• 支援多語言
• 自動儀表化
• 分散式追蹤

Datadog APM

• 全棧監控
• 自動追蹤
• 即時分析

AppDynamics

• 企業級 APM
• 業務交易追蹤
• AI 根因分析

Elastic APM

• 開源方案
• 整合 ELK Stack
• 分散式追蹤

視覺化工具

火焰圖 (Flame Graphs)

FlameGraph

git clone https://github.com/brendangregg/FlameGraph
perf script | ./FlameGraph/stackcollapse-perf.pl | ./FlameGraph/flamegraph.pl > flame.svg

Speedscope

• Web-based viewer
• 支援多種格式
• https://www.speedscope.app/

通用視覺化

Grafana + Prometheus

• 時序資料視覺化
• 監控 Dashboard

kcachegrind/qcachegrind

# Callgrind 資料視覺化
kcachegrind callgrind.out.*

Google Perftools

google-pprof --web program profile.pb.gz

最佳實踐矩陣

選擇指南

依問題類型選擇

Memory Leak

• C/C++: Valgrind, ASan
• Python: tracemalloc, memory_profiler
• Java: MAT, VisualVM
• Go: pprof heap
• JavaScript: Chrome DevTools

CPU Hotspot

• C/C++: perf, VTune
• Python: py-spy, cProfile
• Java: async-profiler, JProfiler
• Go: pprof profile
• Rust: flamegraph

Concurrency Issues

• C/C++: ThreadSanitizer
• Java: jstack, thread dumps
• Go: race detector, trace
• .NET: Concurrency Visualizer

依環境選擇

開發環境

• 使用整合工具 (IDE profilers)
• 可接受高開銷工具

CI/CD

• 自動化工具
• 靜態分析
• Benchmark 套件

生產環境

• 低開銷工具
• APM 解決方案
• 採樣式 profiler

參考資源

• Brendan Gregg's Performance Tools
• Julia Evans' Profiling Zines
• Awesome Performance Tools
• Google Performance Tools
• Linux Performance

C++ 和 Rust 函數追蹤技術完整指南

目錄

• 概述
• GCC 編譯器內建追蹤
• 專業函數追蹤工具
• Rust 追蹤解決方案
• GDB 自動化追蹤
• 系統級追蹤工具
• 進階追蹤技術
• 視覺化工具
• 實用建議與最佳實踐
• 常見問題與解決方案

概述

函數追蹤是理解程式執行流程、診斷問題和優化效能的關鍵技術。本指南涵蓋從基礎到進階的各種追蹤方法，適用於 C++、Rust 等系統程式語言。

為什麼需要函數追蹤？

• 程式碼理解: 快速掌握大型專案的架構和執行邏輯
• 效能優化: 識別熱點函數和效能瓶頸
• 除錯診斷: 追蹤難以重現的錯誤和異常行為
• 記憶體分析: 發現記憶體洩漏和不當使用
• 並發分析: 理解多執行緒程式的執行順序

GCC 編譯器內建追蹤

finstrument-functions 方法

GCC 內建函數插樁是最直接的方法：

# 編譯時加入 -finstrument-functions
gcc -finstrument-functions -g your_program.cpp -o your_program

# 排除特定函數不被插樁
gcc -finstrument-functions -finstrument-functions-exclude-function-list=main,foo -g your_program.cpp

# 排除特定檔案
gcc -finstrument-functions -finstrument-functions-exclude-file-list=/usr/include -g your_program.cpp

基礎實現

#include <stdio.h>
#include <execinfo.h>
#include <dlfcn.h>

extern "C" __attribute__((no_instrument_function))
void __cyg_profile_func_enter(void *callee, void *caller) {
    Dl_info info;
    if (dladdr(callee, &info)) {
        printf(">>> 進入函數: %s [%p]\n", 
               info.dli_sname ? info.dli_sname : "unknown", callee);
    }
}

extern "C" __attribute__((no_instrument_function))  
void __cyg_profile_func_exit(void *callee, void *caller) {
    Dl_info info;
    if (dladdr(callee, &info)) {
        printf("<<< 離開函數: %s [%p]\n", 
               info.dli_sname ? info.dli_sname : "unknown", callee);
    }
}

進階實現：帶時間戳和調用深度

#include <chrono>
#include <stack>
#include <unordered_map>
#include <mutex>

class FunctionTracer {
private:
    static thread_local int depth_;
    static thread_local std::stack<std::chrono::high_resolution_clock::time_point> time_stack_;
    static std::mutex output_mutex_;
    
public:
    static void enter(void* func, void* caller) {
        auto now = std::chrono::high_resolution_clock::now();
        time_stack_.push(now);
        
        std::lock_guard<std::mutex> lock(output_mutex_);
        for (int i = 0; i < depth_; ++i) printf("  ");
        printf("→ %p\n", func);
        depth_++;
    }
    
    static void exit(void* func, void* caller) {
        auto now = std::chrono::high_resolution_clock::now();
        auto duration = now - time_stack_.top();
        time_stack_.pop();
        depth_--;
        
        std::lock_guard<std::mutex> lock(output_mutex_);
        for (int i = 0; i < depth_; ++i) printf("  ");
        printf("← %p [%lld µs]\n", func, 
               std::chrono::duration_cast<std::chrono::microseconds>(duration).count());
    }
};

extern "C" __attribute__((no_instrument_function))
void __cyg_profile_func_enter(void *callee, void *caller) {
    FunctionTracer::enter(callee, caller);
}

extern "C" __attribute__((no_instrument_function))
void __cyg_profile_func_exit(void *callee, void *caller) {
    FunctionTracer::exit(callee, caller);
}

Call Stack Logger 專案

• GitHub: TomaszAugustyn/call-stack-logger
• 功能特色:
  • 自動函數名稱解析和記憶體地址轉換
  • 帶縮進的調用樹狀結構輸出
  • 時間戳記錄和調用深度追蹤
  • 支援多執行緒程式的完整追蹤
  • 輸出到檔案或標準輸出

Clang 編譯器支援

Clang 也支援類似的功能：

# Clang 使用相同的選項
clang++ -finstrument-functions -g program.cpp -o program

# Clang 特有的 XRay 追蹤
clang++ -fxray-instrument -g program.cpp -o program
XRAY_OPTIONS="patch_premain=true xray_mode=xray-basic" ./program

專業函數追蹤工具

uftrace - 強大的使用者空間追蹤工具

• GitHub: namhyung/uftrace
• 安裝:

# Ubuntu/Debian
sudo apt-get install uftrace

# Fedora/RHEL
sudo dnf install uftrace

# 從原始碼編譯
git clone https://github.com/namhyung/uftrace.git
cd uftrace
./configure
make
sudo make install

基本使用

# 編譯程式時加入追蹤選項
gcc -pg -g program.c -o program
# 或者
gcc -finstrument-functions -g program.c -o program

# 追蹤執行
uftrace record ./program
uftrace replay

# 即時追蹤並顯示
uftrace ./program

# 只顯示執行時間超過 1ms 的函數
uftrace -t 1ms ./program

# 追蹤特定函數
uftrace -F main -F process_data ./program

# 生成調用圖
uftrace graph

進階功能

# 記錄函數參數和返回值
uftrace record -A . -R . ./program

# 生成火焰圖
uftrace record ./program
uftrace dump --flame-graph | flamegraph.pl > flame.svg

# 生成 Chrome tracing 格式
uftrace dump --chrome > trace.json
# 在 Chrome 中開啟 chrome://tracing 並載入 trace.json

# 統計函數執行時間
uftrace report --stats

# 追蹤 Python 程式
uftrace record -t 1ms python3 script.py

其他追蹤工具專案

funtrace

• GitHub: yosefk/funtrace
• 特色: 快速、小型函數調用追蹤器，適合嵌入式系統

# 使用範例
gcc -finstrument-functions program.c funtrace.c -ldl -o program
./program

ftracer

• GitHub: finaldie/ftracer
• 特色: 生成時間軸調用圖的工具包

# 編譯時連結 ftracer
gcc -finstrument-functions program.c -lftracer -o program
FTRACER_OUTPUT=trace.log ./program
ftracer_plot trace.log > timeline.html

tracer

• GitHub: mohsenmahroos/tracer
• 特色: 簡單的 C++ 追蹤類別，使用 RAII 模式

#include "tracer.h"

void function() {
    TRACE_FUNC();  // 自動追蹤函數進入和離開
    // 函數邏輯
}

Valgrind Callgrind

# 編譯程式（需要調試符號）
gcc -g program.c -o program

# 使用 callgrind 追蹤
valgrind --tool=callgrind ./program

# 生成調用圖
callgrind_annotate callgrind.out.*

# 使用 KCachegrind 視覺化
kcachegrind callgrind.out.*

Rust 追蹤解決方案

tracing crate - Rust 官方推薦

基本設置

# Cargo.toml
[dependencies]
tracing = "0.1"
tracing-subscriber = "0.3"
tokio = { version = "1", features = ["full"] }

使用範例

use tracing::{instrument, info, warn, error, span, Level};
use tracing_subscriber;

// 自動為函數添加追蹤
#[instrument(level = "info", ret, err)]
async fn process_data(data: &str) -> Result<String, Error> {
    info!("Processing data: {}", data);
    
    // 創建子 span
    let span = span!(Level::DEBUG, "validation");
    let _enter = span.enter();
    
    if data.is_empty() {
        warn!("Empty data received");
        return Err(Error::EmptyData);
    }
    
    Ok(data.to_uppercase())
}

// 追蹤異步函數
#[instrument(skip(db), fields(user_id = %user_id))]
async fn fetch_user(db: &Database, user_id: u64) -> Result<User, Error> {
    let user = db.get_user(user_id).await?;
    info!("Found user: {}", user.name);
    Ok(user)
}

fn main() {
    // 初始化追蹤訂閱器
    tracing_subscriber::fmt()
        .with_max_level(Level::TRACE)
        .with_thread_ids(true)
        .with_thread_names(true)
        .with_file(true)
        .with_line_number(true)
        .init();
    
    // 程式邏輯
}

進階配置

#![allow(unused)]
fn main() {
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

fn init_tracing() {
    let fmt_layer = tracing_subscriber::fmt::layer()
        .with_target(false)
        .with_timer(tracing_subscriber::fmt::time::uptime())
        .with_level(true)
        .with_thread_ids(true)
        .with_thread_names(true);
    
    // 添加過濾器
    let filter_layer = tracing_subscriber::EnvFilter::try_from_default_env()
        .unwrap_or_else(|_| "info,my_app=debug".into());
    
    tracing_subscriber::registry()
        .with(filter_layer)
        .with(fmt_layer)
        .init();
}
}

rftrace - Rust 函數追蹤器

• GitHub: hermit-os/rftrace
• 功能: 專為 Rust 設計的函數追蹤器，支援內核和使用者空間的完整追蹤

cargo-flamegraph

# 安裝
cargo install flamegraph

# 生成火焰圖
cargo flamegraph --bin my_program

# 使用 release 模式並保留調試符號
cargo flamegraph --release -- my_arg1 my_arg2

GDB 自動化追蹤

GDB 腳本自動記錄

基礎腳本

# trace_all.gdb
set pagination off
set logging file trace.log
set logging on
set height 0

# 為所有函數設置斷點
rbreak .*

# 定義自動執行的命令
commands
silent
printf ">>> %s\n", $rip
backtrace 1
continue
end

# 執行程式
run

執行方式：

gdb -x trace_all.gdb ./program

進階腳本：選擇性追蹤

# selective_trace.gdb
set pagination off
set logging file trace.log
set logging on

# 只追蹤特定模組的函數
rbreak MyClass::.*
rbreak process_.*

# 記錄函數參數
commands
silent
printf "Function: "
x/i $pc
info args
info locals
continue
end

run

Python 擴展 GDB 腳本

# trace_with_time.py
import gdb
import time

class FunctionTracer(gdb.Command):
    def __init__(self):
        super().__init__("trace-functions", gdb.COMMAND_USER)
        self.start_time = time.time()
        
    def invoke(self, arg, from_tty):
        # 設置所有函數斷點
        gdb.execute("rbreak .*")
        
        # 定義斷點處理
        def on_breakpoint(event):
            if isinstance(event, gdb.BreakpointEvent):
                frame = gdb.selected_frame()
                elapsed = time.time() - self.start_time
                print(f"[{elapsed:.6f}] {frame.name()}")
                gdb.execute("continue")
        
        gdb.events.stop.connect(on_breakpoint)
        gdb.execute("run")

FunctionTracer()

系統級追蹤工具

ltrace 和 strace

ltrace - 庫函數追蹤

# 基本使用
ltrace ./program

# 追蹤特定庫函數
ltrace -e malloc+free+strcpy ./program

# 顯示時間戳
ltrace -t ./program

# 追蹤子進程
ltrace -f ./program

# 統計函數調用
ltrace -c ./program

# 追蹤已執行的進程
ltrace -p $(pidof program)

strace - 系統調用追蹤

# 基本使用
strace ./program

# 只追蹤特定系統調用
strace -e open,read,write ./program

# 追蹤網路相關調用
strace -e trace=network ./program

# 顯示調用時間
strace -T ./program

# 統計系統調用
strace -c ./program

# 追蹤所有子進程
strace -ff -o trace ./program

SystemTap

# 安裝
sudo apt-get install systemtap systemtap-runtime

# 簡單的函數追蹤腳本
# trace_functions.stp
probe process("./program").function("*") {
    printf("%s -> %s\n", thread_indent(1), probefunc())
}

probe process("./program").function("*").return {
    printf("%s <- %s\n", thread_indent(-1), probefunc())
}

# 執行
sudo stap trace_functions.stp -c ./program

eBPF/BCC 工具

#!/usr/bin/python
# trace_functions.py
from bcc import BPF

# BPF 程式
bpf_text = """
#include <uapi/linux/ptrace.h>

int trace_func_entry(struct pt_regs *ctx) {
    u64 pid = bpf_get_current_pid_tgid();
    bpf_trace_printk("PID %d entered function\\n", pid >> 32);
    return 0;
}
"""

# 載入 BPF 程式
b = BPF(text=bpf_text)
b.attach_uprobe(name="./program", sym="main", fn_name="trace_func_entry")

# 讀取輸出
b.trace_print()

進階追蹤技術

Intel VTune Profiler

# 收集數據
vtune -collect hotspots ./program

# 分析結果
vtune -report summary -r r000hs

# GUI 模式
vtune-gui r000hs

AMD uProf

# 收集效能數據
AMDuProfCLI collect --config tbp ./program

# 生成報告
AMDuProfCLI report -i AMDuProf-program/

Linux Perf

# 記錄函數調用
perf record -g ./program

# 查看報告
perf report

# 生成火焰圖
perf record -F 99 -g ./program
perf script | stackcollapse-perf.pl | flamegraph.pl > perf.svg

# 即時監控
perf top -g

DTrace (macOS/FreeBSD/Solaris)

/* trace_functions.d */
pid$target::*:entry
{
    printf("%*s-> %s\n", ++indent * 2, "", probefunc);
}

pid$target::*:return
{
    printf("%*s<- %s\n", indent-- * 2, "", probefunc);
}

執行：

sudo dtrace -s trace_functions.d -c ./program

視覺化工具

火焰圖 (Flame Graphs)

# 安裝 FlameGraph 工具
git clone https://github.com/brendangregg/FlameGraph
cd FlameGraph

# 使用 perf 生成火焰圖
perf record -F 99 -ag -- ./program
perf script | ./stackcollapse-perf.pl | ./flamegraph.pl > flame.svg

# 使用 uftrace 生成火焰圖
uftrace record ./program
uftrace dump --flame-graph | ./flamegraph.pl > flame.svg

Perfetto UI

# 生成 Perfetto 格式追蹤
uftrace record ./program
uftrace dump --chrome > trace.json

# 開啟 https://ui.perfetto.dev/ 並載入 trace.json

KCachegrind

# 生成 callgrind 數據
valgrind --tool=callgrind ./program

# 視覺化
kcachegrind callgrind.out.*

Graphviz 調用圖

# 使用 uftrace 生成 dot 檔案
uftrace record ./program
uftrace graph -f dot > call_graph.dot

# 轉換為圖片
dot -Tpng call_graph.dot -o call_graph.png
dot -Tsvg call_graph.dot -o call_graph.svg

實用建議與最佳實踐

快速開始方案

C++ 專案

1. 輕量級追蹤: 使用 -finstrument-functions 配合簡單的追蹤函數
2. 完整分析: 使用 uftrace 配合 -pg 編譯選項
3. 效能分析: 使用 perf 或 VTune
4. 記憶體分析: 使用 Valgrind 配合 Callgrind

Rust 專案

1. 開發階段: 使用 tracing crate 的 #[instrument] 宏
2. 效能分析: 使用 cargo-flamegraph
3. 系統級追蹤: 使用 uftrace 或 perf

無法重編譯的程式

1. 動態追蹤: 使用 GDB 自動化腳本
2. 系統調用: 使用 strace
3. 庫函數: 使用 ltrace
4. 進階追蹤: 使用 SystemTap 或 eBPF

效能考量

降低追蹤開銷

// 使用條件編譯
#ifdef ENABLE_TRACING
    #define TRACE_FUNC() FunctionTracer tracer(__FUNCTION__)
#else
    #define TRACE_FUNC()
#endif

// 採樣追蹤
static std::atomic<int> sample_counter{0};
extern "C" void __cyg_profile_func_enter(void *callee, void *caller) {
    if (++sample_counter % 100 == 0) {  // 只追蹤 1% 的調用
        // 執行追蹤
    }
}

過濾策略

# uftrace: 時間過濾
uftrace -t 10us ./program  # 只顯示超過 10 微秒的函數

# uftrace: 深度過濾
uftrace -D 3 ./program  # 只追蹤 3 層深度

# uftrace: 函數過濾
uftrace -F main -F 'process_*' ./program  # 只追蹤特定函數
uftrace -N 'std::*' ./program  # 排除 std 命名空間

多執行緒追蹤

// 執行緒安全的追蹤實現
#include <thread>
#include <mutex>
#include <unordered_map>

class ThreadSafeTracer {
private:
    static std::mutex mutex_;
    static std::unordered_map<std::thread::id, int> depth_map_;
    
public:
    static void enter(void* func) {
        std::lock_guard<std::mutex> lock(mutex_);
        auto tid = std::this_thread::get_id();
        auto& depth = depth_map_[tid];
        
        std::cout << "[" << tid << "] ";
        for (int i = 0; i < depth; ++i) std::cout << "  ";
        std::cout << "→ " << func << std::endl;
        depth++;
    }
};

分散式追蹤

OpenTelemetry 整合

#![allow(unused)]
fn main() {
// Rust with OpenTelemetry
use opentelemetry::{global, sdk::propagation::TraceContextPropagator};
use tracing_subscriber::layer::SubscriberExt;

fn init_telemetry() {
    global::set_text_map_propagator(TraceContextPropagator::new());
    
    let tracer = opentelemetry_jaeger::new_pipeline()
        .with_service_name("my_service")
        .install_simple()
        .unwrap();
    
    let telemetry = tracing_opentelemetry::layer().with_tracer(tracer);
    
    tracing_subscriber::registry()
        .with(telemetry)
        .init();
}
}

常見問題與解決方案

問題 1：符號解析失敗

症狀: 只看到記憶體地址，沒有函數名稱

解決方案:

# 確保編譯時包含調試符號
gcc -g -O0 program.c -o program

# 保留符號表（即使在 strip 後）
gcc -g program.c -o program
objcopy --only-keep-debug program program.debug
strip program
objcopy --add-gnu-debuglink=program.debug program

# 使用 addr2line 解析地址
addr2line -e program 0x401234

問題 2：追蹤開銷過大

症狀: 程式執行速度明顯變慢

解決方案:

// 1. 使用編譯時開關
#ifdef DEBUG_TRACE
    // 追蹤程式碼
#endif

// 2. 動態開關
bool g_tracing_enabled = false;
extern "C" void __cyg_profile_func_enter(void *callee, void *caller) {
    if (!g_tracing_enabled) return;
    // 追蹤邏輯
}

// 3. 選擇性追蹤
// 只追蹤特定模組
gcc -finstrument-functions src/core/*.c -c
gcc src/other/*.c -c  # 不加追蹤選項

問題 3：輸出過多難以分析

症狀: 追蹤日誌檔案過大，難以找到關鍵資訊

解決方案:

# 1. 使用過濾器
uftrace -F main -D 3 ./program  # 只看 main 函數 3 層深度

# 2. 後處理過濾
grep "error\|warning" trace.log

# 3. 使用結構化日誌
# 輸出 JSON 格式，便於程式化處理
uftrace dump --format=json > trace.json
jq '.[] | select(.name | contains("process"))' trace.json

問題 4：靜態連結程式無法追蹤

症狀: ltrace 無輸出，uftrace 無法工作

解決方案:

# 1. 使用 strace（系統調用仍可追蹤）
strace ./static_program

# 2. 重新編譯為動態連結
gcc -dynamic program.c -o program

# 3. 使用 GDB 或 SystemTap
gdb ./static_program
systemtap -e 'probe process("static_program").function("*") { println(probefunc()) }'

問題 5：即時系統的追蹤

症狀: 追蹤影響即時性能

解決方案:

// 使用無鎖資料結構
#include <atomic>
#include <array>

class LockFreeTracer {
    struct TraceEntry {
        void* func;
        uint64_t timestamp;
    };
    
    static std::array<TraceEntry, 10000> buffer_;
    static std::atomic<size_t> index_;
    
public:
    static void trace(void* func) {
        size_t idx = index_.fetch_add(1) % buffer_.size();
        buffer_[idx] = {func, get_timestamp()};
    }
};

使用場景建議

總結

函數追蹤是強大的程式分析技術，選擇合適的工具和方法能夠大幅提升開發和除錯效率。從簡單的編譯器插樁到複雜的動態追蹤，每種方法都有其適用場景。關鍵是根據具體需求選擇最合適的解決方案，並在追蹤開銷和資訊價值之間找到平衡。

快速決策樹

1. 能否重新編譯？

   • 是 → 使用 -finstrument-functions 或 -pg
   • 否 → 使用 GDB/ltrace/strace

2. 需要視覺化？

   • 是 → uftrace + Chrome tracing 或火焰圖
   • 否 → 簡單文字輸出即可

3. 效能敏感？

   • 是 → 使用採樣式追蹤（perf）或 eBPF
   • 否 → 完整插樁追蹤

4. 多執行緒程式？

   • 是 → 確保追蹤工具支援執行緒安全
   • 否 → 任何工具皆可

記住：好的追蹤策略應該是漸進式的，從簡單開始，根據需要逐步增加複雜度。

Flamegraph 火焰圖完整指南

一、什麼是 Flamegraph？

1.1 基本概念

Flamegraph（火焰圖）是一種性能分析的視覺化工具，由 Brendan Gregg 發明。它能夠快速識別程式中最耗費 CPU 時間的代碼路徑。

     ┌─────────────────────────────────┐  ← 寬度 = CPU 時間佔比
     │         function_d()             │
     ├──────────┬──────────────────────┤
     │function_c│    function_e()       │  ← 每層 = 調用棧深度
     ├──────────┴──────────┬───────────┤
     │    function_b()      │function_f │
     ├──────────────────────┴───────────┤
     │           function_a()           │  ← 底部 = 程式入口
     └─────────────────────────────────┘

1.2 視覺化原理

• X 軸（寬度）：表示採樣數量（CPU 時間佔比）
• Y 軸（高度）：表示調用棧深度
• 顏色：通常用來區分不同類型的函數（系統/用戶/庫函數）
• 火焰形狀：因為越往上函數越少，看起來像火焰

二、Flamegraph 類型

2.1 CPU 火焰圖

最常見的類型，顯示 CPU 時間消耗

# 採集 CPU 性能數據
perf record -F 99 -p <PID> -g -- sleep 60
perf script > out.perf

2.2 Memory 火焰圖

顯示記憶體分配的調用棧

# 使用 brendangregg/FlameGraph 工具
perf record -e malloc -g -p <PID> -- sleep 60

2.3 Off-CPU 火焰圖

顯示程式阻塞（非 CPU 執行）的時間

# 追蹤 off-CPU 時間
bpftrace -e 'tracepoint:sched:sched_switch { @[kstack, ustack, comm] = sum(nsecs); }'

2.4 Differential 火焰圖

比較兩個版本的性能差異

# 紅色表示增加的時間，藍色表示減少的時間
flamegraph.pl --title="Diff" --colors=java diff.folded > diff.svg

三、安裝與使用

3.1 安裝 FlameGraph 工具

# Clone Brendan Gregg 的官方倉庫
git clone https://github.com/brendangregg/FlameGraph.git
cd FlameGraph

# 添加到 PATH（可選）
export PATH=$PATH:$(pwd)

3.2 基本使用流程

# 步驟 1: 收集性能數據
perf record -F 99 -p $(pgrep myapp) -g -- sleep 30

# 步驟 2: 生成性能報告
perf script > out.perf

# 步驟 3: 摺疊調用棧
./stackcollapse-perf.pl out.perf > out.folded

# 步驟 4: 生成火焰圖
./flamegraph.pl out.folded > flamegraph.svg

# 步驟 5: 在瀏覽器中查看
firefox flamegraph.svg

四、高頻交易場景應用

4.1 延遲分析範例

// 範例：高頻交易系統的關鍵路徑
class TradingEngine {
public:
    void processMarketData(const MarketData& data) {
        // 標記性能追蹤點
        TRACE_ENTER("processMarketData");
        
        parseData(data);           // 10% CPU
        updateOrderBook(data);      // 15% CPU
        calculateSignals();         // 45% CPU ← 火焰圖會顯示這是熱點
        executeStrategy();          // 20% CPU
        sendOrders();              // 10% CPU
        
        TRACE_EXIT("processMarketData");
    }
};

4.2 採集腳本

#!/bin/bash
# hft_flamegraph.sh - 高頻交易系統火焰圖生成腳本

PID=$(pgrep trading_engine)
DURATION=60
OUTPUT_DIR="./flamegraphs"

mkdir -p $OUTPUT_DIR

# CPU 火焰圖
echo "Collecting CPU samples..."
perf record -F 999 -p $PID -g -o $OUTPUT_DIR/perf.data -- sleep $DURATION
perf script -i $OUTPUT_DIR/perf.data > $OUTPUT_DIR/out.perf
./stackcollapse-perf.pl $OUTPUT_DIR/out.perf > $OUTPUT_DIR/out.folded
./flamegraph.pl --title="HFT CPU Flamegraph" \
                --subtitle="Sample rate: 999 Hz" \
                --width=1800 \
                $OUTPUT_DIR/out.folded > $OUTPUT_DIR/cpu_flame.svg

echo "Flamegraph saved to $OUTPUT_DIR/cpu_flame.svg"

4.3 延遲熱點識別

# 分析火焰圖數據，找出延遲熱點
def analyze_flamegraph_data(folded_file):
    """
    解析 folded 格式的火焰圖數據
    格式: stack;frame1;frame2;frame3 count
    """
    hotspots = {}
    total_samples = 0
    
    with open(folded_file, 'r') as f:
        for line in f:
            stack, count = line.rsplit(' ', 1)
            count = int(count)
            total_samples += count
            
            # 提取每個函數的採樣數
            for func in stack.split(';'):
                hotspots[func] = hotspots.get(func, 0) + count
    
    # 計算百分比並排序
    sorted_hotspots = sorted(
        [(func, count, count/total_samples*100) 
         for func, count in hotspots.items()],
        key=lambda x: x[1],
        reverse=True
    )
    
    print("Top 10 CPU Hotspots:")
    for func, count, percentage in sorted_hotspots[:10]:
        print(f"{percentage:6.2f}% - {func}")

五、進階技巧

5.1 自定義顏色方案

# 修改 flamegraph.pl 的顏色配置
my %palette = (
    "hot" => "rgb(255,0,0)",      # 熱點函數 - 紅色
    "kernel" => "rgb(255,128,0)",  # 核心函數 - 橘色  
    "jit" => "rgb(255,255,0)",     # JIT 代碼 - 黃色
    "user" => "rgb(0,255,0)",      # 用戶代碼 - 綠色
);

5.2 過濾和聚焦

# 只顯示包含特定函數的調用棧
grep processOrder out.folded | ./flamegraph.pl > order_processing.svg

# 排除某些函數
grep -v idle out.folded | ./flamegraph.pl > no_idle.svg

# 聚焦特定模組
./flamegraph.pl --title="Strategy Module" \
                --minwidth=0.5 \
                --grep="strategy" \
                out.folded > strategy_focus.svg

5.3 即時火焰圖

#!/bin/bash
# 即時生成火焰圖（每 10 秒更新）

while true; do
    perf record -F 99 -p $PID -g -o perf.data -- sleep 10
    perf script -i perf.data | \
        ./stackcollapse-perf.pl | \
        ./flamegraph.pl --title="Real-time $(date +%T)" > realtime.svg
    
    # 更新網頁顯示
    mv realtime.svg /var/www/html/flamegraph.svg
done

5.4 與 BPF 結合

#!/usr/bin/python
# 使用 BPF 生成更精確的火焰圖

from bcc import BPF
import time

# BPF 程式
bpf_text = """
#include <uapi/linux/ptrace.h>

BPF_STACK_TRACE(stack_traces, 10240);
BPF_HASH(counts, u32);

int do_trace(struct pt_regs *ctx) {
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    
    // 只追蹤特定 PID
    if (pid != TARGET_PID)
        return 0;
    
    u32 stackid = stack_traces.get_stackid(ctx, BPF_F_USER_STACK);
    counts.increment(stackid);
    
    return 0;
}
"""

# 編譯並載入 BPF
b = BPF(text=bpf_text.replace('TARGET_PID', str(target_pid)))
b.attach_perf_event(ev_type=PerfType.SOFTWARE,
                    ev_config=PerfSWConfig.CPU_CLOCK,
                    fn_name="do_trace",
                    sample_freq=99)

# 收集數據
time.sleep(60)

# 生成火焰圖數據
for k, v in b["counts"].items():
    stack = b["stack_traces"].lookup(k)
    # 處理並輸出調用棧...

六、優化建議

6.1 採樣頻率選擇

採樣頻率建議:
  日常分析: 99 Hz    # 避免與常見定時器頻率共振
  詳細分析: 999 Hz   # 更高精度，但開銷較大
  生產環境: 49 Hz    # 最小化性能影響
  
計算公式:
  樣本數 = 採樣頻率 × 採集時間
  建議最少 1000 個樣本以獲得有意義的結果

6.2 降低採集開銷

# 使用 Intel PT (Processor Trace) - 硬體級追蹤
perf record -e intel_pt// -p $PID -- sleep 10

# 只採集特定事件
perf record -e cycles:u -p $PID -- sleep 10  # 只採集用戶空間

# 使用 LBR (Last Branch Record)
perf record --call-graph lbr -p $PID -- sleep 10

6.3 高頻交易系統特別優化

// 在關鍵路徑添加採樣點
class PerformanceTracer {
public:
    // 使用編譯時開關，生產環境可完全移除
    #ifdef ENABLE_TRACING
    #define TRACE_POINT(name) tracer.mark(name)
    #else
    #define TRACE_POINT(name) ((void)0)
    #endif
    
    void mark(const char* point) {
        // 寫入低延遲的環形緩衝區
        // 避免系統調用
        ring_buffer.write(rdtsc(), point);
    }
};

// 使用範例
void processOrder(Order& order) {
    TRACE_POINT("order_received");
    validateOrder(order);
    
    TRACE_POINT("risk_check_start");
    if (!riskCheck(order)) return;
    
    TRACE_POINT("send_to_exchange");
    exchange.send(order);
}

七、常見問題解析

7.1 為什麼火焰圖是平的？

可能原因:
  1. 採樣頻率太低: 增加到 999 Hz
  2. 程式太簡單: 沒有深度調用棧
  3. 內聯優化: 編譯器內聯了函數
  4. 符號資訊缺失: 需要 -g 編譯選項
  
解決方案:
  - 使用 -fno-omit-frame-pointer 編譯
  - 確保有調試符號
  - 增加採樣時間

7.2 火焰圖太複雜看不懂

# 簡化技巧
# 1. 按模組過濾
grep -E "strategy|trading" out.folded | ./flamegraph.pl > simplified.svg

# 2. 設定最小寬度閾值
./flamegraph.pl --minwidth=1 out.folded > cleaner.svg

# 3. 限制棧深度
awk -F';' 'NF<=10' out.folded | ./flamegraph.pl > shallow.svg

7.3 如何比較優化前後？

# 生成差異火焰圖
# 1. 收集優化前數據
perf record -o before.data -p $PID -g -- sleep 60
perf script -i before.data | ./stackcollapse-perf.pl > before.folded

# 2. 部署優化後收集
perf record -o after.data -p $PID -g -- sleep 60
perf script -i after.data | ./stackcollapse-perf.pl > after.folded

# 3. 生成差異圖
./difffolded.pl before.folded after.folded | \
    ./flamegraph.pl --title="Optimization Diff" --colors=java > diff.svg

八、實戰案例

8.1 發現記憶體分配熱點

// 問題代碼 - 火焰圖顯示 malloc 佔 30% CPU
void processTickData(const Tick& tick) {
    // 每次都分配新 vector - 性能問題！
    std::vector<double> prices;  
    prices.push_back(tick.bid);
    prices.push_back(tick.ask);
    calculate(prices);
}

// 優化後 - 重用記憶體
class TickProcessor {
    std::vector<double> prices_buffer;  // 預分配
public:
    void processTickData(const Tick& tick) {
        prices_buffer.clear();  // 只清空，不釋放
        prices_buffer.push_back(tick.bid);
        prices_buffer.push_back(tick.ask);
        calculate(prices_buffer);
    }
};

8.2 識別鎖競爭

# Off-CPU 火焰圖能顯示鎖等待時間
# 如果看到大量 futex_wait，表示鎖競爭嚴重

# 採集 off-CPU 數據
bpftrace -e '
tracepoint:sched:sched_switch {
    if (args->prev_state == TASK_INTERRUPTIBLE) {
        @lock_wait[kstack] = sum(nsecs);
    }
}'

九、整合到 CI/CD

9.1 自動性能回歸測試

# .github/workflows/performance.yml
name: Performance Regression Test

on: [push, pull_request]

jobs:
  perf-test:
    steps:
      - name: Run Performance Test
        run: |
          ./run_load_test.sh
          perf record -F 99 -g ./trading_engine_test
          
      - name: Generate Flamegraph
        run: |
          perf script | ./stackcollapse-perf.pl > out.folded
          ./flamegraph.pl out.folded > flamegraph.svg
          
      - name: Upload Artifacts
        uses: actions/upload-artifact@v2
        with:
          name: flamegraph
          path: flamegraph.svg
          
      - name: Check Performance Regression
        run: |
          python check_performance.py --baseline main.folded \
                                     --current out.folded \
                                     --threshold 5

9.2 性能儀表板整合

// 將火焰圖嵌入 Grafana
const FlameGraphPanel = {
  type: 'html',
  targets: [{
    format: 'table',
    rawSql: `
      SELECT 
        timestamp,
        flamegraph_url
      FROM performance_tests
      ORDER BY timestamp DESC
      LIMIT 1
    `
  }],
  content: '<iframe src="{{flamegraph_url}}" width="100%" height="600"/>'
};

十、簡單程式範例

10.1 CPU 密集型程式範例

// cpu_intensive.cpp - 用來練習生成 CPU 火焰圖
#include <iostream>
#include <vector>
#include <cmath>
#include <chrono>

// 故意寫效率差的質數判斷（教學用）
bool is_prime_slow(int n) {
    if (n <= 1) return false;
    for (int i = 2; i < n; i++) {  // 故意不優化到 sqrt(n)
        if (n % i == 0) return false;
    }
    return true;
}

// 稍微優化的版本
bool is_prime_better(int n) {
    if (n <= 1) return false;
    if (n <= 3) return true;
    if (n % 2 == 0 || n % 3 == 0) return false;
    
    for (int i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0)
            return false;
    }
    return true;
}

// 計算費波那契數列（遞迴版本 - 效率差）
long fibonacci_recursive(int n) {
    if (n <= 1) return n;
    return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2);
}

// 矩陣運算（會顯示在火焰圖中）
void matrix_multiply(std::vector<std::vector<int>>& A,
                     std::vector<std::vector<int>>& B,
                     std::vector<std::vector<int>>& C) {
    int n = A.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            C[i][j] = 0;
            for (int k = 0; k < n; k++) {
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }
}

int main() {
    std::cout << "Starting CPU intensive tasks...\n";
    
    // 任務 1: 找質數（預期佔 40% CPU）
    std::cout << "Task 1: Finding primes...\n";
    int prime_count = 0;
    for (int i = 1; i <= 50000; i++) {
        if (is_prime_slow(i)) prime_count++;
    }
    std::cout << "Found " << prime_count << " primes\n";
    
    // 任務 2: 費波那契（預期佔 30% CPU）
    std::cout << "Task 2: Computing Fibonacci...\n";
    for (int i = 1; i <= 35; i++) {
        fibonacci_recursive(i);
    }
    
    // 任務 3: 矩陣運算（預期佔 30% CPU）
    std::cout << "Task 3: Matrix multiplication...\n";
    int size = 200;
    std::vector<std::vector<int>> A(size, std::vector<int>(size, 1));
    std::vector<std::vector<int>> B(size, std::vector<int>(size, 2));
    std::vector<std::vector<int>> C(size, std::vector<int>(size, 0));
    
    for (int i = 0; i < 10; i++) {
        matrix_multiply(A, B, C);
    }
    
    std::cout << "All tasks completed!\n";
    return 0;
}

編譯和生成火焰圖：

# 編譯（保留符號資訊和框架指標）
g++ -g -O2 -fno-omit-frame-pointer cpu_intensive.cpp -o cpu_intensive

# 執行並收集性能數據
./cpu_intensive &
PID=$!
sleep 1  # 等程式開始
perf record -F 99 -p $PID -g -- sleep 10

# 生成火焰圖
perf script | ./stackcollapse-perf.pl | ./flamegraph.pl > cpu_intensive.svg

# 預期結果：
# - is_prime_slow() 佔約 40% 寬度
# - fibonacci_recursive() 佔約 30% 寬度（且調用棧很深）
# - matrix_multiply() 佔約 30% 寬度

10.2 記憶體分配範例

// memory_allocation.cpp - 用來練習生成 Memory 火焰圖
#include <iostream>
#include <vector>
#include <list>
#include <memory>
#include <cstring>

// 問題 1：頻繁的小記憶體分配
void frequent_small_allocations() {
    for (int i = 0; i < 100000; i++) {
        // 每次都 new 一個小物件（反面教材）
        int* p = new int(i);
        // 做一些計算
        *p = *p * 2;
        delete p;
    }
}

// 問題 2：vector 不當使用導致多次重新分配
void vector_reallocation_problem() {
    std::vector<int> vec;
    // 沒有 reserve，導致多次重新分配
    for (int i = 0; i < 100000; i++) {
        vec.push_back(i);  // 可能觸發重新分配
    }
}

// 問題 3：字串拼接的記憶體問題
void string_concatenation_problem() {
    std::string result;
    for (int i = 0; i < 10000; i++) {
        // 每次 += 可能導致重新分配
        result += "Hello World ";
    }
}

// 優化版本：使用物件池
class ObjectPool {
    std::vector<int*> pool;
    std::vector<int*> available;
    
public:
    ObjectPool(size_t size) {
        for (size_t i = 0; i < size; i++) {
            int* obj = new int(0);
            pool.push_back(obj);
            available.push_back(obj);
        }
    }
    
    int* acquire() {
        if (available.empty()) {
            return new int(0);
        }
        int* obj = available.back();
        available.pop_back();
        return obj;
    }
    
    void release(int* obj) {
        available.push_back(obj);
    }
    
    ~ObjectPool() {
        for (auto* obj : pool) {
            delete obj;
        }
    }
};

void optimized_with_pool() {
    ObjectPool pool(1000);
    
    for (int i = 0; i < 100000; i++) {
        int* p = pool.acquire();
        *p = i * 2;
        pool.release(p);
    }
}

int main() {
    std::cout << "Starting memory allocation tests...\n";
    
    // 執行有問題的版本
    std::cout << "Running problematic versions...\n";
    frequent_small_allocations();
    vector_reallocation_problem();
    string_concatenation_problem();
    
    // 執行優化版本
    std::cout << "Running optimized version...\n";
    optimized_with_pool();
    
    std::cout << "Completed!\n";
    return 0;
}

追蹤記憶體分配：

# 使用 heaptrack（更適合記憶體分析）
heaptrack ./memory_allocation
heaptrack --analyze heaptrack.memory_allocation.*.gz

# 或使用 perf
perf record -e kmem:kmalloc -g ./memory_allocation
perf script | ./stackcollapse-perf.pl | ./flamegraph.pl > memory.svg

10.3 多執行緒與鎖競爭範例

// lock_contention.cpp - 用來練習生成 Off-CPU 火焰圖
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <atomic>
#include <chrono>

std::mutex global_mutex;
std::atomic<long> shared_counter(0);

// 問題：過度使用全域鎖
void bad_locking_thread(int thread_id) {
    for (int i = 0; i < 100000; i++) {
        // 鎖的粒度太大
        std::lock_guard<std::mutex> lock(global_mutex);
        
        // 在鎖裡面做太多事情
        int local_computation = 0;
        for (int j = 0; j < 100; j++) {
            local_computation += j * thread_id;
        }
        shared_counter += local_computation;
    }
}

// 優化：減少鎖的粒度
void better_locking_thread(int thread_id) {
    for (int i = 0; i < 100000; i++) {
        // 先在鎖外面計算
        int local_computation = 0;
        for (int j = 0; j < 100; j++) {
            local_computation += j * thread_id;
        }
        
        // 只在必要時加鎖
        std::lock_guard<std::mutex> lock(global_mutex);
        shared_counter += local_computation;
    }
}

// 最優：使用原子操作
void atomic_thread(int thread_id) {
    for (int i = 0; i < 100000; i++) {
        int local_computation = 0;
        for (int j = 0; j < 100; j++) {
            local_computation += j * thread_id;
        }
        
        // 使用原子操作代替鎖
        shared_counter.fetch_add(local_computation, std::memory_order_relaxed);
    }
}

int main(int argc, char* argv[]) {
    const int num_threads = 8;
    std::vector<std::thread> threads;
    
    std::string mode = (argc > 1) ? argv[1] : "bad";
    
    auto start = std::chrono::high_resolution_clock::now();
    
    if (mode == "bad") {
        std::cout << "Running with bad locking...\n";
        for (int i = 0; i < num_threads; i++) {
            threads.emplace_back(bad_locking_thread, i);
        }
    } else if (mode == "better") {
        std::cout << "Running with better locking...\n";
        for (int i = 0; i < num_threads; i++) {
            threads.emplace_back(better_locking_thread, i);
        }
    } else {
        std::cout << "Running with atomic operations...\n";
        for (int i = 0; i < num_threads; i++) {
            threads.emplace_back(atomic_thread, i);
        }
    }
    
    for (auto& t : threads) {
        t.join();
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    
    std::cout << "Result: " << shared_counter << std::endl;
    std::cout << "Time: " << duration.count() << " ms" << std::endl;
    
    return 0;
}

生成 Off-CPU 火焰圖查看鎖等待：

# 編譯
g++ -g -O2 -pthread -fno-omit-frame-pointer lock_contention.cpp -o lock_contention

# 使用 bpftrace 追蹤 off-CPU 時間
sudo bpftrace -e '
tracepoint:sched:sched_switch {
    @start[tid] = nsecs;
}

tracepoint:sched:sched_switch {
    $duration = nsecs - @start[tid];
    @offcpu[kstack, ustack, comm] = sum($duration);
    delete(@start[tid]);
}

END {
    clear(@start);
}' > offcpu.txt

# 運行三種模式比較
./lock_contention bad    # 會看到大量 mutex 等待
./lock_contention better # mutex 等待減少
./lock_contention atomic # 幾乎沒有等待

10.4 高頻交易模擬範例

// hft_simulation.cpp - 模擬高頻交易系統的關鍵路徑
#include <iostream>
#include <vector>
#include <deque>
#include <algorithm>
#include <random>
#include <chrono>
#include <cstring>

struct MarketData {
    double bid;
    double ask;
    long timestamp;
    int volume;
};

struct Order {
    enum Type { BUY, SELL };
    Type type;
    double price;
    int quantity;
    long timestamp;
};

class OrderBook {
private:
    std::deque<Order> bids;
    std::deque<Order> asks;
    
public:
    // 這個函數會在火焰圖中顯示為熱點
    void update(const MarketData& data) {
        // 模擬訂單簿更新（簡化版）
        Order bid_order = {Order::BUY, data.bid, data.volume, data.timestamp};
        Order ask_order = {Order::SELL, data.ask, data.volume, data.timestamp};
        
        // 插入排序（實際系統會用更高效的資料結構）
        bids.push_back(bid_order);
        std::sort(bids.begin(), bids.end(), 
                  [](const Order& a, const Order& b) { 
                      return a.price > b.price; 
                  });
        
        asks.push_back(ask_order);
        std::sort(asks.begin(), asks.end(),
                  [](const Order& a, const Order& b) { 
                      return a.price < b.price; 
                  });
        
        // 限制深度
        if (bids.size() > 100) bids.resize(100);
        if (asks.size() > 100) asks.resize(100);
    }
    
    double get_mid_price() const {
        if (bids.empty() || asks.empty()) return 0;
        return (bids.front().price + asks.front().price) / 2.0;
    }
};

class TradingStrategy {
private:
    std::vector<double> price_history;
    const size_t window_size = 20;
    
public:
    // 簡單的均值回歸策略（會佔用 CPU）
    Order* generate_signal(const OrderBook& book) {
        double mid_price = book.get_mid_price();
        price_history.push_back(mid_price);
        
        if (price_history.size() < window_size) {
            return nullptr;
        }
        
        // 計算移動平均（這裡會顯示在火焰圖中）
        double sum = 0;
        for (size_t i = price_history.size() - window_size; 
             i < price_history.size(); i++) {
            sum += price_history[i];
        }
        double ma = sum / window_size;
        
        // 計算標準差（另一個熱點）
        double variance = 0;
        for (size_t i = price_history.size() - window_size; 
             i < price_history.size(); i++) {
            double diff = price_history[i] - ma;
            variance += diff * diff;
        }
        double std_dev = std::sqrt(variance / window_size);
        
        // 簡單的交易信號
        if (mid_price < ma - 2 * std_dev) {
            return new Order{Order::BUY, mid_price, 100, 0};
        } else if (mid_price > ma + 2 * std_dev) {
            return new Order{Order::SELL, mid_price, 100, 0};
        }
        
        return nullptr;
    }
};

class RiskManager {
private:
    double max_position = 10000;
    double current_position = 0;
    double max_loss = -1000;
    double current_pnl = 0;
    
public:
    // 風控檢查（關鍵路徑，需要極快）
    bool check_order(const Order* order) {
        if (!order) return true;
        
        // 檢查持倉限制
        double position_change = (order->type == Order::BUY) ? 
                                order->quantity : -order->quantity;
        
        if (std::abs(current_position + position_change) > max_position) {
            return false;
        }
        
        // 檢查損失限制
        if (current_pnl < max_loss) {
            return false;
        }
        
        return true;
    }
    
    void update_position(const Order* order) {
        if (!order) return;
        
        double position_change = (order->type == Order::BUY) ? 
                                order->quantity : -order->quantity;
        current_position += position_change;
    }
};

// 主要的交易循環
void trading_loop(int num_ticks) {
    OrderBook book;
    TradingStrategy strategy;
    RiskManager risk;
    
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<> price_dist(99.0, 101.0);
    std::uniform_int_distribution<> volume_dist(100, 1000);
    
    auto start = std::chrono::high_resolution_clock::now();
    
    for (int i = 0; i < num_ticks; i++) {
        // 生成模擬市場數據
        MarketData data;
        data.bid = price_dist(gen);
        data.ask = data.bid + 0.01;
        data.volume = volume_dist(gen);
        data.timestamp = std::chrono::duration_cast<std::chrono::microseconds>(
            std::chrono::high_resolution_clock::now().time_since_epoch()).count();
        
        // 關鍵路徑開始 >>>
        
        // 1. 更新訂單簿（預期 30% CPU）
        book.update(data);
        
        // 2. 生成交易信號（預期 40% CPU）
        Order* signal = strategy.generate_signal(book);
        
        // 3. 風控檢查（預期 10% CPU）
        if (risk.check_order(signal)) {
            // 4. 發送訂單（預期 20% CPU）
            risk.update_position(signal);
            // 實際系統這裡會發送到交易所
        }
        
        delete signal;
        
        // <<< 關鍵路徑結束
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
    
    double latency_per_tick = static_cast<double>(duration.count()) / num_ticks;
    std::cout << "Processed " << num_ticks << " ticks\n";
    std::cout << "Average latency: " << latency_per_tick << " microseconds/tick\n";
}

int main() {
    std::cout << "Starting HFT simulation...\n";
    
    // 預熱
    trading_loop(1000);
    
    // 主要測試
    std::cout << "Running main test...\n";
    trading_loop(1000000);
    
    return 0;
}

生成高頻交易系統的火焰圖：

# 編譯（開啟優化但保留調試資訊）
g++ -g -O3 -march=native -fno-omit-frame-pointer hft_simulation.cpp -o hft_sim

# 運行並收集數據
./hft_sim &
PID=$!

# 等待程式進入主循環
sleep 2

# 收集 30 秒的性能數據（高採樣率）
sudo perf record -F 999 -p $PID -g -- sleep 30

# 生成火焰圖
sudo perf script | ./stackcollapse-perf.pl | \
    ./flamegraph.pl --title="HFT System Flame Graph" \
                    --subtitle="1000 Hz sampling" \
                    --width=1800 > hft_flame.svg

# 預期在火焰圖中看到：
# - OrderBook::update() 約 30% 寬度
# - TradingStrategy::generate_signal() 約 40% 寬度
#   - 其中計算移動平均和標準差是主要熱點
# - RiskManager::check_order() 約 10% 寬度
# - 其他（包括記憶體操作等）約 20% 寬度

10.5 生成對比火焰圖的腳本

#!/bin/bash
# compare_performance.sh - 對比優化前後的性能

# 顏色定義
RED='\033[0;31m'
GREEN='\033[0;32m'
NC='\033[0m' # No Color

echo -e "${GREEN}Performance Comparison Script${NC}"

# 編譯兩個版本
echo "Compiling baseline version..."
g++ -g -O2 -fno-omit-frame-pointer -DBASELINE cpu_intensive.cpp -o baseline

echo "Compiling optimized version..."
g++ -g -O3 -march=native -fno-omit-frame-pointer cpu_intensive.cpp -o optimized

# 收集基準版本數據
echo -e "${RED}Collecting baseline performance data...${NC}"
./baseline &
PID=$!
sleep 1
perf record -F 99 -p $PID -g -o baseline.data -- sleep 10
wait $PID

# 收集優化版本數據
echo -e "${GREEN}Collecting optimized performance data...${NC}"
./optimized &
PID=$!
sleep 1
perf record -F 99 -p $PID -g -o optimized.data -- sleep 10
wait $PID

# 生成火焰圖
echo "Generating flame graphs..."
perf script -i baseline.data | ./stackcollapse-perf.pl > baseline.folded
perf script -i optimized.data | ./stackcollapse-perf.pl > optimized.folded

# 生成單獨的火焰圖
./flamegraph.pl baseline.folded > baseline.svg
./flamegraph.pl optimized.folded > optimized.svg

# 生成對比火焰圖
./difffolded.pl baseline.folded optimized.folded | \
    ./flamegraph.pl --title="Optimization Comparison" \
                    --subtitle="Red = Slower, Blue = Faster" \
                    --colors=java > diff.svg

echo "Generated files:"
echo "  - baseline.svg (baseline performance)"
echo "  - optimized.svg (optimized performance)"
echo "  - diff.svg (performance difference)"

# 簡單的性能統計
echo -e "\n${GREEN}Performance Summary:${NC}"
echo -n "Baseline samples: "
awk '{sum+=$NF} END {print sum}' baseline.folded
echo -n "Optimized samples: "
awk '{sum+=$NF} END {print sum}' optimized.folded

# 找出最大的改進
echo -e "\n${GREEN}Top improvements:${NC}"
./difffolded.pl baseline.folded optimized.folded | \
    sort -t' ' -k2 -nr | head -5

這些範例程式涵蓋了：

• CPU 密集型：質數計算、遞迴、矩陣運算
• 記憶體問題：頻繁分配、vector 重分配、物件池優化
• 多執行緒：鎖競爭、原子操作優化
• 高頻交易模擬：完整的交易路徑
• 自動化對比：優化前後的性能比較腳本

每個範例都有詳細的編譯和執行指令，以及預期在火焰圖中看到的結果。

十一、總結與最佳實踐

關鍵要點

1. 火焰圖是性能優化的 X 光片 - 能快速定位熱點
2. 寬度比高度重要 - 寬的函數才是優化目標
3. 不同類型解決不同問題 - CPU/Memory/Off-CPU 各有用途
4. 採樣要有代表性 - 確保覆蓋典型工作負載
5. 結合其他工具使用 - perf、BPF、VTune 等

高頻交易場景注意事項

• 使用硬體時間戳（TSC）提高精度
• 區分熱路徑和冷路徑的優化優先級
• 關注尾延遲（P99.9）而非平均值
• 定期生成火焰圖，追蹤性能變化趨勢
• 在測試環境模擬生產負載

進一步學習資源

• Brendan Gregg's Blog
• Linux Perf Examples
• BPF Performance Tools
• Intel VTune Profiler

🪙 Solana 代幣系統白話文完整指南

🤔 首先搞懂：什麼時候需要 Rust？

不需要 Rust 的情況（大多數情況）

✅ 創建普通代幣 → 用 Solana CLI 就夠了
✅ 建立出入金系統 → 用 Python/JavaScript 就行
✅ 錢包整合 → 前端框架即可
✅ 一般 DeFi 功能 → 組合現有程式就好

需要 Rust 的情況（特殊需求）

❌ 自定義代幣邏輯 → 例如：每次轉帳收 1% 手續費
❌ 複雜智能合約 → 例如：多重簽名、投票系統
❌ 高性能應用 → 例如：高頻交易、遊戲引擎
❌ 創新金融產品 → 例如：新型 AMM、借貸協議

總結：90% 的專案用不到 Rust！

💰 出入金系統詳細解析

什麼是出入金？

• 入金（充值）：用戶從自己錢包 → 轉到平台
• 出金（提現）：用戶從平台 → 轉到自己錢包

為什麼需要出入金系統？

🏦 傳統交易所模式：
用戶錢包 ↔ 交易所系統 ↔ 區塊鏈

優點：
✅ 交易快速（不用等區塊鏈確認）
✅ 手續費便宜（內部轉帳免費）
✅ 用戶體驗好（像銀行 APP）

缺點：
❌ 需要信任平台
❌ 平台可能跑路

🔄 出入金完整流程圖

📱 用戶操作流程：

1️⃣ 註冊階段：
用戶連接錢包 → 系統產生專用充值地址 → 用戶獲得帳號

2️⃣ 充值流程：
用戶錢包 → 轉帳到充值地址 → 系統監控到帳 → 更新用戶餘額

3️⃣ 內部交易：
用戶A餘額 → 扣除金額 → 用戶B餘額增加（秒到）

4️⃣ 提現流程：
檢查用戶餘額 → 從熱錢包轉出 → 到達用戶錢包 → 扣除用戶餘額

💻 完整系統架構

整體架構圖

🌐 前端 (React + 錢包連接)
     ↕ API 呼叫
🖥️ 後端 (Python FastAPI)
     ↕ 讀寫
🗄️ 資料庫 (PostgreSQL)
     ↕ 監控
⛓️ Solana 區塊鏈

詳細的出入金實作

1. 充值監控系統（最重要！）

# app/services/deposit_monitor.py - 白話版解釋
import asyncio
from decimal import Decimal
from solana.rpc.async_api import AsyncClient
from solders.pubkey import Pubkey

class DepositMonitor:
    """
    充值監控器 - 這是整個系統的核心！
    
    作用：不停地檢查用戶的充值地址，看有沒有新的轉帳進來
    就像銀行系統監控你的帳戶一樣
    """
    
    def __init__(self, solana_service):
        self.service = solana_service
        self.processed_transactions = set()  # 記住已經處理過的交易
        self.is_running = False
    
    async def start_monitoring(self):
        """開始無限循環監控"""
        self.is_running = True
        print("🔍 開始監控所有用戶的充值...")
        
        while self.is_running:
            try:
                # 每5秒檢查一次所有用戶
                await self.check_all_user_deposits()
                await asyncio.sleep(5)
            except Exception as e:
                print(f"❌ 監控出錯: {e}")
                await asyncio.sleep(10)  # 出錯就等久一點再試
    
    async def check_all_user_deposits(self):
        """檢查所有用戶的充值地址"""
        
        # 從資料庫取出所有用戶的充值地址
        async with self.service.db_pool.acquire() as conn:
            users = await conn.fetch(
                "SELECT user_id, deposit_address FROM user_balances WHERE deposit_address IS NOT NULL"
            )
        
        # 一個一個檢查
        for user in users:
            await self.check_single_user_deposit(user['user_id'], user['deposit_address'])
    
    async def check_single_user_deposit(self, user_id: str, deposit_address: str):
        """檢查單一用戶的充值"""
        try:
            # 轉換地址格式
            pubkey = Pubkey.from_string(deposit_address)
            
            # 向 Solana 區塊鏈查詢這個地址的最近交易
            signatures = await self.service.client.get_signatures_for_address(
                pubkey, 
                limit=20  # 只看最近20筆交易就夠了
            )
            
            # 檢查每一筆交易
            for sig_info in signatures.value:
                signature = sig_info.signature
                
                # 如果這筆交易已經處理過，就跳過
                if signature in self.processed_transactions:
                    continue
                
                # 處理新交易
                await self.process_new_deposit(user_id, signature)
                
                # 記住這筆交易已經處理過了
                self.processed_transactions.add(signature)
                
        except Exception as e:
            print(f"❌ 檢查用戶 {user_id} 充值失敗: {e}")
    
    async def process_new_deposit(self, user_id: str, transaction_signature: str):
        """處理新的充值交易"""
        try:
            # 獲取交易的詳細資料
            tx_detail = await self.service.client.get_transaction(transaction_signature)
            
            if not tx_detail.value:
                return  # 交易不存在就跳過
            
            # 解析交易，找出轉了多少代幣
            token_amount = await self.parse_token_amount_from_transaction(tx_detail.value)
            
            if token_amount > 0:
                # 增加用戶餘額
                await self.credit_user_balance(user_id, token_amount, transaction_signature)
                
                # 通知用戶（可選）
                await self.notify_user_deposit_success(user_id, token_amount)
                
                print(f"✅ 用戶 {user_id} 充值成功: {token_amount} 代幣")
                
        except Exception as e:
            print(f"❌ 處理充值交易失敗: {e}")
    
    async def parse_token_amount_from_transaction(self, transaction) -> Decimal:
        """
        從交易中解析出代幣數量
        這裡簡化處理，實際需要解析 Solana 交易結構
        """
        # 實際實作需要：
        # 1. 解析 transaction.transaction.message.instructions
        # 2. 找到 SPL Token 轉帳指令
        # 3. 提取轉帳金額
        # 4. 轉換小數位數
        
        # 這裡用固定值示範
        return Decimal('100.5')  # 假設轉了 100.5 個代幣
    
    async def credit_user_balance(self, user_id: str, amount: Decimal, tx_signature: str):
        """增加用戶餘額並記錄交易"""
        async with self.service.db_pool.acquire() as conn:
            async with conn.transaction():  # 使用資料庫交易確保一致性
                
                # 增加用戶餘額
                await conn.execute(
                    """
                    UPDATE user_balances 
                    SET token_balance = token_balance + $1,
                        updated_at = NOW()
                    WHERE user_id = $2
                    """,
                    amount, user_id
                )
                
                # 記錄充值交易
                await conn.execute(
                    """
                    INSERT INTO transactions 
                    (user_id, tx_signature, type, amount, status, confirmed_at)
                    VALUES ($1, $2, 'deposit', $3, 'confirmed', NOW())
                    """,
                    user_id, tx_signature, amount
                )
    
    async def notify_user_deposit_success(self, user_id: str, amount: Decimal):
        """通知用戶充值成功（可選功能）"""
        # 可以整合：
        # 1. WebSocket 即時通知
        # 2. 推播通知
        # 3. Email 通知
        # 4. Telegram Bot 通知
        pass

2. 提現處理系統

# app/services/withdrawal_service.py - 白話版
from decimal import Decimal
from typing import Dict
from solana.rpc.async_api import AsyncClient
from solders.pubkey import Pubkey
from spl.token.async_client import AsyncToken
from spl.token.constants import TOKEN_PROGRAM_ID

class WithdrawalService:
    """
    提現服務 - 處理用戶提現到自己錢包
    
    重要概念：
    - 熱錢包：平台控制的錢包，用來發送代幣給用戶
    - 冷錢包：離線存儲大部分代幣，安全性高
    """
    
    def __init__(self, solana_service):
        self.service = solana_service
        self.withdrawal_fee = Decimal('0.1')    # 提現手續費
        self.min_withdrawal = Decimal('10')     # 最小提現金額
        self.max_daily_withdrawal = Decimal('10000')  # 每日提現限額
    
    async def process_user_withdrawal(self, user_id: str, amount: Decimal, target_wallet: str) -> Dict:
        """
        處理用戶提現請求
        
        流程：
        1. 檢查用戶餘額夠不夠
        2. 檢查提現限制（最小金額、每日限額等）
        3. 從熱錢包轉帳到用戶錢包
        4. 扣除用戶平台餘額
        5. 記錄交易
        """
        try:
            # 第一步：各種檢查
            validation_result = await self.validate_withdrawal_request(user_id, amount, target_wallet)
            if not validation_result['valid']:
                return {'success': False, 'error': validation_result['error']}
            
            # 第二步：計算總費用（提現金額 + 手續費）
            total_cost = amount + self.withdrawal_fee
            
            # 第三步：檢查用戶餘額
            user_balance = await self.service.get_user_balance(user_id)
            if user_balance < total_cost:
                return {
                    'success': False, 
                    'error': f'餘額不足，需要 {total_cost}（包含手續費 {self.withdrawal_fee}）'
                }
            
            # 第四步：執行區塊鏈轉帳
            blockchain_result = await self.send_tokens_on_blockchain(amount, target_wallet)
            if not blockchain_result['success']:
                return {'success': False, 'error': f'區塊鏈轉帳失敗: {blockchain_result["error"]}'}
            
            # 第五步：更新資料庫（扣除用戶餘額、記錄交易）
            await self.update_database_after_withdrawal(
                user_id, amount, target_wallet, blockchain_result['signature']
            )
            
            return {
                'success': True,
                'transaction_signature': blockchain_result['signature'],
                'amount_sent': str(amount),
                'fee_charged': str(self.withdrawal_fee),
                'target_wallet': target_wallet,
                'explorer_url': f'https://solscan.io/tx/{blockchain_result["signature"]}'
            }
            
        except Exception as e:
            # 記錄錯誤日誌
            await self.log_withdrawal_error(user_id, amount, target_wallet, str(e))
            return {'success': False, 'error': f'系統錯誤: {str(e)}'}
    
    async def validate_withdrawal_request(self, user_id: str, amount: Decimal, target_wallet: str) -> Dict:
        """驗證提現請求是否合法"""
        
        # 檢查金額是否符合限制
        if amount < self.min_withdrawal:
            return {'valid': False, 'error': f'提現金額不能少於 {self.min_withdrawal}'}
        
        # 檢查錢包地址格式
        try:
            Pubkey.from_string(target_wallet)
        except:
            return {'valid': False, 'error': '錢包地址格式錯誤'}
        
        # 檢查每日提現限額
        daily_withdrawn = await self.get_user_daily_withdrawal_amount(user_id)
        if daily_withdrawn + amount > self.max_daily_withdrawal:
            return {
                'valid': False, 
                'error': f'超過每日提現限額 {self.max_daily_withdrawal}，今日已提現 {daily_withdrawn}'
            }
        
        # 檢查用戶狀態
        user_status = await self.get_user_account_status(user_id)
        if user_status != 'active':
            return {'valid': False, 'error': '帳戶已被凍結'}
        
        return {'valid': True}
    
    async def send_tokens_on_blockchain(self, amount: Decimal, target_wallet: str) -> Dict:
        """在區塊鏈上執行實際的代幣轉帳"""
        try:
            # 建立 SPL Token 客戶端
            token_client = AsyncToken(
                self.service.client,           # Solana RPC 連接
                self.service.token_mint,       # 我們的代幣合約地址
                TOKEN_PROGRAM_ID,              # SPL Token 程式 ID
                self.service.hot_wallet        # 平台熱錢包（用來發送代幣）
            )
            
            # 獲取目標錢包的代幣帳戶（如果沒有就創建一個）
            target_pubkey = Pubkey.from_string(target_wallet)
            target_token_account = await token_client.get_or_create_associated_account_info(target_pubkey)
            
            # 獲取平台熱錢包的代幣帳戶
            source_token_account = await token_client.get_or_create_associated_account_info(
                self.service.hot_wallet.pubkey()
            )
            
            # 轉換金額格式（考慮代幣的小數位數）
            # 假設我們的代幣有 9 位小數
            token_amount_raw = int(amount * (10 ** 9))
            
            # 執行轉帳
            transfer_response = await token_client.transfer(
                source=source_token_account,    # 從熱錢包
                dest=target_token_account,      # 到用戶錢包
                owner=self.service.hot_wallet,  # 簽名者（熱錢包）
                amount=token_amount_raw         # 轉帳金額
            )
            
            # 等待交易確認
            confirmation = await self.service.client.confirm_transaction(transfer_response.value)
            
            return {
                'success': True,
                'signature': str(transfer_response.value)
            }
            
        except Exception as e:
            return {
                'success': False,
                'error': str(e)
            }
    
    async def update_database_after_withdrawal(self, user_id: str, amount: Decimal, target_wallet: str, tx_signature: str):
        """提現成功後更新資料庫"""
        total_deducted = amount + self.withdrawal_fee
        
        async with self.service.db_pool.acquire() as conn:
            async with conn.transaction():
                
                # 扣除用戶餘額
                await conn.execute(
                    """
                    UPDATE user_balances 
                    SET token_balance = token_balance - $1,
                        updated_at = NOW()
                    WHERE user_id = $2
                    """,
                    total_deducted, user_id
                )
                
                # 記錄提現交易
                await conn.execute(
                    """
                    INSERT INTO transactions 
                    (user_id, tx_signature, type, amount, to_address, fee, status, confirmed_at)
                    VALUES ($1, $2, 'withdraw', $3, $4, $5, 'confirmed', NOW())
                    """,
                    user_id, tx_signature, amount, target_wallet, self.withdrawal_fee
                )
                
                print(f"✅ 用戶 {user_id} 提現 {amount} 代幣到 {target_wallet}")
    
    async def get_user_daily_withdrawal_amount(self, user_id: str) -> Decimal:
        """查詢用戶今日已提現金額"""
        async with self.service.db_pool.acquire() as conn:
            result = await conn.fetchval(
                """
                SELECT COALESCE(SUM(amount), 0)
                FROM transactions 
                WHERE user_id = $1 
                  AND type = 'withdraw' 
                  AND status = 'confirmed'
                  AND DATE(confirmed_at) = CURRENT_DATE
                """,
                user_id
            )
            return Decimal(result)
    
    async def get_user_account_status(self, user_id: str) -> str:
        """查詢用戶帳戶狀態"""
        async with self.service.db_pool.acquire() as conn:
            result = await conn.fetchval(
                "SELECT status FROM user_balances WHERE user_id = $1",
                user_id
            )
            return result or 'inactive'

3. 內部轉帳系統（用戶之間互轉）

# app/services/internal_transfer.py - 白話版
class InternalTransferService:
    """
    內部轉帳服務 - 用戶在平台內互相轉帳
    
    優點：
    - 不用上區塊鏈，秒到帳
    - 不用付 Gas 費
    - 就像銀行內部轉帳一樣快
    """
    
    def __init__(self, solana_service):
        self.service = solana_service
        self.transfer_fee = Decimal('0')  # 內部轉帳免手續費
    
    async def transfer_between_users(self, from_user: str, to_user: str, amount: Decimal, memo: str = "") -> Dict:
        """用戶之間轉帳"""
        try:
            # 檢查轉帳金額
            if amount <= 0:
                return {'success': False, 'error': '轉帳金額必須大於 0'}
            
            # 檢查發送方餘額
            sender_balance = await self.service.get_user_balance(from_user)
            if sender_balance < amount:
                return {'success': False, 'error': '餘額不足'}
            
            # 檢查接收方是否存在
            receiver_exists = await self.check_user_exists(to_user)
            if not receiver_exists:
                return {'success': False, 'error': '接收方用戶不存在'}
            
            # 執行轉帳（原子操作）
            async with self.service.db_pool.acquire() as conn:
                async with conn.transaction():
                    
                    # 扣除發送方餘額
                    await conn.execute(
                        "UPDATE user_balances SET token_balance = token_balance - $1 WHERE user_id = $2",
                        amount, from_user
                    )
                    
                    # 增加接收方餘額
                    await conn.execute(
                        "UPDATE user_balances SET token_balance = token_balance + $1 WHERE user_id = $2",
                        amount, to_user
                    )
                    
                    # 記錄轉帳
                    transfer_id = await conn.fetchval(
                        """
                        INSERT INTO internal_transfers 
                        (from_user, to_user, amount, memo, status, created_at)
                        VALUES ($1, $2, $3, $4, 'completed', NOW())
                        RETURNING id
                        """,
                        from_user, to_user, amount, memo
                    )
            
            return {
                'success': True,
                'transfer_id': transfer_id,
                'from_user': from_user,
                'to_user': to_user,
                'amount': str(amount),
                'memo': memo
            }
            
        except Exception as e:
            return {'success': False, 'error': str(e)}

🗄️ 完整資料庫設計

-- 用戶餘額表
CREATE TABLE user_balances (
    user_id VARCHAR(64) PRIMARY KEY,           -- 用戶ID（通常是錢包地址）
    wallet_address VARCHAR(64) UNIQUE NOT NULL,-- 用戶的主錢包地址
    deposit_address VARCHAR(64) UNIQUE,        -- 平台分配的充值地址
    token_balance DECIMAL(20,8) DEFAULT 0,     -- 用戶在平台的代幣餘額
    status VARCHAR(20) DEFAULT 'active',       -- 帳戶狀態
    created_at TIMESTAMP DEFAULT NOW(),
    updated_at TIMESTAMP DEFAULT NOW()
);

-- 交易記錄表（區塊鏈交易）
CREATE TABLE transactions (
    id SERIAL PRIMARY KEY,
    user_id VARCHAR(64) NOT NULL,
    tx_signature VARCHAR(128) UNIQUE,          -- 區塊鏈交易簽名
    type VARCHAR(20) CHECK (type IN ('deposit', 'withdraw')),
    amount DECIMAL(20,8) NOT NULL,
    from_address VARCHAR(64),
    to_address VARCHAR(64),
    fee DECIMAL(20,8) DEFAULT 0,              -- 手續費
    status VARCHAR(20) DEFAULT 'pending',      -- pending, confirmed, failed
    created_at TIMESTAMP DEFAULT NOW(),
    confirmed_at TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES user_balances(user_id)
);

-- 內部轉帳表（不上鏈）
CREATE TABLE internal_transfers (
    id SERIAL PRIMARY KEY,
    from_user VARCHAR(64) NOT NULL,
    to_user VARCHAR(64) NOT NULL,
    amount DECIMAL(20,8) NOT NULL,
    memo TEXT,                                -- 轉帳備註
    status VARCHAR(20) DEFAULT 'completed',
    created_at TIMESTAMP DEFAULT NOW(),
    FOREIGN KEY (from_user) REFERENCES user_balances(user_id),
    FOREIGN KEY (to_user) REFERENCES user_balances(user_id)
);

-- 系統設置表
CREATE TABLE system_settings (
    key VARCHAR(50) PRIMARY KEY,
    value TEXT NOT NULL,
    description TEXT,
    updated_at TIMESTAMP DEFAULT NOW()
);

-- 插入基本設置
INSERT INTO system_settings (key, value, description) VALUES
('withdrawal_fee', '0.1', '提現手續費'),
('min_withdrawal', '10', '最小提現金額'),
('max_daily_withdrawal', '10000', '每日提現限額'),
('deposit_confirmations', '12', '充值需要的確認數');

🎯 用戶使用流程（白話版）

1. 用戶註冊

用戶：我要註冊
1. 用戶連接 Phantom 錢包
2. 系統：看到你的錢包地址了，幫你創建帳號
3. 系統：這是你的專用充值地址：ABC123...
4. 用戶：好，我記住了

2. 充值（入金）

用戶：我要充值 100 個代幣
1. 用戶從自己錢包轉 100 代幣到充值地址
2. 系統監控程式：咦，ABC123 地址收到 100 代幣了
3. 系統：確認是這個用戶的，幫他加餘額
4. 用戶：看到平台餘額變成 100 了，開心！

3. 內部交易

用戶A：我要轉 50 代幣給用戶B
1. 系統：檢查用戶A餘額夠不夠
2. 系統：夠，扣除用戶A的 50，增加用戶B的 50
3. 用戶A：餘額變成 50
4. 用戶B：餘額增加 50，秒到帳！

4. 提現（出金）

用戶：我要提現 30 代幣到我錢包
1. 系統：檢查餘額、手續費、限額
2. 系統：OK，從熱錢包轉 30 代幣到你錢包
3. 區塊鏈：交易確認
4. 系統：扣除用戶餘額 30 + 手續費
5. 用戶：錢包收到 30 代幣！

💡 關鍵概念解釋

熱錢包 vs 冷錢包

🔥 熱錢包（Hot Wallet）：
- 連網的錢包，平台控制
- 用來處理日常出入金
- 風險：被駭客攻擊
- 建議：只放少量資金

🧊 冷錢包（Cold Wallet）：
- 離線錢包，超級安全
- 存放大部分資金
- 風險：操作麻煩
- 建議：定期從熱錢包轉入

託管 vs 非託管

🏦 託管模式（我們的系統）：
- 平台幫你保管代幣
- 交易快速、體驗好
- 需要信任平台

🔑 非託管模式（DeFi）：
- 用戶自己控制私鑰
- 去中心化、不用信任
- 交易慢、Gas費高

🚀 詳細快速啟動指南

準備工作（5分鐘）

# 檢查系統需求
echo "檢查 Python 版本..."
python3 --version  # 需要 3.8+

echo "檢查 Node.js 版本..."
node --version  # 需要 16+

echo "檢查 Docker..."
docker --version  # 需要最新版

echo "檢查 Git..."
git --version

第一步：創建代幣（詳細版 - 15分鐘）

1.1 安裝 Solana 工具鏈

# macOS/Linux
echo "🔧 安裝 Solana CLI..."
sh -c "$(curl -sSfL https://release.solana.com/v1.18.4/install)"

# 重新載入環境變數
export PATH="$HOME/.local/share/solana/install/active_release/bin:$PATH"

# 驗證安裝
solana --version
echo "✅ Solana CLI 安裝完成"

# 安裝 SPL Token CLI
echo "🔧 安裝 SPL Token CLI..."
cargo install spl-token-cli --version 3.4.0

# 驗證安裝
spl-token --version
echo "✅ SPL Token CLI 安裝完成"

1.2 設定錢包和網路

# 設定為測試網
echo "🌐 設定 Solana 測試網..."
solana config set --url https://api.devnet.solana.com

# 創建新錢包
echo "💰 創建主錢包..."
solana-keygen new --outfile ~/solana-mainnet-wallet.json --force

# 設定為預設錢包
solana config set --keypair ~/solana-mainnet-wallet.json

# 查看錢包地址
WALLET_ADDRESS=$(solana-keygen pubkey ~/solana-mainnet-wallet.json)
echo "錢包地址: $WALLET_ADDRESS"

# 查看當前配置
solana config get

1.3 獲取測試幣並創建代幣